Transcripciones
1. Introducción: Oye, ahí está Max y
bienvenido a tu misión SQL. En esta misión,
vas a
aprender a usar SQL para procesar así
como analizar datos directamente en la base de datos
usando consultas SQL. Al final de esta misión,
vas a poder escribir consultas SQL
que se vean así, y también aprenderás qué son las bases de datos
relacionales A lo largo del curso, primero
vas a comenzar con tu configuración. Entonces vas a
entrar en algunos conceptos básicos sobre tablas, bases de datos y consultas. Vas a aprender
sobre aritmética. Vas a
aprender sobre fechas y horas, manipular datos, y luego vas
a adentrarte también en cosas
más complejas como
uniones, uniones y funciones de ventana Entonces me emociona
que empieces.
2. Introducción de datos relacionales: Hey ahi, x max y bienvenidos. Entonces en esta lección vamos a aprender sobre bases de datos
relacionales solo para asegurarnos de que todos estén en el mismo nivel, que todo el mundo tenga el mismo conocimiento
sobre las bases de datos relacionales y que todos estamos familiarizados con los términos clave para que cuando realmente empecemos a usar SQL y aprendiendo SQL, cuando escuches alguno de los términos necesarios, entiendas exactamente de lo que estoy hablando. Por lo que en primer lugar, las bases de datos
relacionales o en un modelo relacional se dividen en tablas. Por lo que una base de datos se va a conformar por varias tablas, pero empecemos primero con la tabla. Entonces, por ejemplo, podemos tener una mesa como vemos a la derecha aquí. Lo primero que notamos es que la tabla tiene un nombre, cual se puede ver arriba. Ahora esta es justamente la forma en que voy a demostrarlo. Por lo general, el nombre va a ser representado en otro lugar. Pero solo para asegurarnos de que todo esté vinculado aquí, tendremos el nombre en la parte superior. Por lo que en este caso nuestro nombre es el subrayado del usuario y el teléfono. Ahora notarás algo sobre la nomenclatura, que está ahí para las convenciones generales de nomenclatura. Uno de ellos está usando un guion bajo y el otro está usando letras mayúsculas. Se puede ver el ejemplo de letras mayúsculas en el ID de usuario, que es una columna en nuestra tabla de información de usuario. Estas dos opciones son simplemente diferentes convenciones de nomenclatura y están ahí solo para ayudarte, al usuario o tal vez también
al administrador de
la base de datos o a cualquier otra persona que necesite usar esta base de datos, poder leer todo más fácil, ya que es mucho más fácil leer palabras que están separadas por un guión bajo o palabras donde cada nueva palabra comienza con una letra mayúscula. Y es mucho más fácil leer palabras así donde todo es minúscula
o mayúscula o algo así. Y así probablemente verás que una de estas dos convenciones de nomenclatura se está usando cuando estás usando una base de datos SQL, por ejemplo, en una empresa, o cuando obtienes una en una entrevista técnica o algo así. Ahora como probablemente lo hayas notado y probablemente ya lo sepas, las tablas están hechas de filas y columnas y es de la misma manera en una base de datos relacional. Por lo que podemos ver aquí nuestra tabla, la tabla userinfo tiene cuatro columnas diferentes llamadas ID de usuario, otra llamada nombre, otra llamada join, y otra llamada email. Y también tiene diferentes filas. Podemos ver aquí tenemos tres filas en este caso. Entonces hablaremos más de eso en un segundo. Pero sí, este va a ser el tipo de estructura
base que nuestra base de datos está conformada por diferentes tablas. Cada tabla tiene un nombre, y cada tabla también está formada por columnas y filas. Ahora cada tabla en una base de datos relacional también tiene algo llamado clave primaria. La clave principal es la columna que identifica de manera única cada fila. Entonces podemos ver aquí, en este caso, nuestra clave principal va a ser el ID de usuario, lo que significa que cada fila necesita tener un ID de usuario único. Esta clave primaria puede surgir de forma natural. Por ejemplo, en nuestra tabla userinfo, el ID de usuario va a ser único por diseño porque cada usuario va a tener un ID único. Y así, por tanto, el ID de usuario es una gran columna para usar como clave primaria. Pero en otros casos, la clave primaria puede ser una columna adicional porque no hay ninguna columna en nuestra tabla que no realmente dé como resultado una prueba gratuita de identificación única. De cualquier manera, una clave primaria en tablas importante porque eso es lo que nos va a permitir identificar cada registro en nuestra base de datos de manera individual. Y así es importante que tengamos una columna para la clave primaria porque de esa manera podemos tener un identificador único para cada fila que tenemos en nuestra tabla. Ahora algo más que es importante es la clave primaria. Sólo puede haber uno por mesa. No se pueden tener dos claves primarias en una tabla. Entonces la clave primaria sólo va a ser una, y también nos va a permitir identificar de manera única cada fila. Ahora estamos usando los términos fila y columnas. Pero en realidad en SQL, por lo general las columnas se van a llamar atributos y las filas se van a llamar registros. Y así puedes pensar en que las columnas son atributos a cada uno de nuestros registros. Nuevamente, los registros son filas. Entonces, por ejemplo, si nos fijamos en la primera fila o en el primer registro, tenemos el UserID 1. Por lo que el atributo de nuestra primera fila donde tiene un ID de usuario de uno y nombre. Alice se unió el 11 de mayo y un correo electrónico a en abc.com. Entonces esto va a ser una especie de la sintaxis que
probablemente escucharás cuando estés mirando tablas y ya sabes, escuchando sobre filas y columnas o más bien registros y atributos. Ahora como mencioné antes, por lo general una base de datos va a tener varias tablas en lugar de solo una. Entonces por ejemplo, nuestra base de datos me, puede
ser sobre usuarios y almacenar información de
usuario así como información sobre los eventos que los usuarios están haciendo. Y así pudimos ver tablas, por ejemplo, llamadas UserInfo, que teníamos antes, quien también podíamos tener otra tabla llamada registro de eventos. Y podemos tener otra tabla llamada Event Info. Y todas estas mesas van a estar relacionadas de alguna manera. Por lo general, no la mejor manera de definir estas relaciones es a través de algo llamado clave extranjera. Entonces por ejemplo, en nuestro registro de eventos tenemos dos claves foráneas. Y con las claves foráneas son, es, son columnas en esa tabla que hace referencia a la clave principal en otra tabla. Entonces, por ejemplo, echemos un vistazo a la tabla de registro de eventos. Aquí tenemos dos llaves extranjeras. Uno de ellos va a ser el ID de usuario. Ahora el ID de usuario hace referencia a la columna ID y a la tabla userinfo. Y tenemos otra llave extranjera aquí llamada el ID del evento. Ahora el ID del evento va a hacer referencia a la columna ID en la tabla de información del evento. Y así de esa manera, también podemos estructurar las relaciones entre nuestras diferentes mesas. Ya que de lo contrario sería ineficiente para nosotros almacenar todos estos datos en la misma tabla. Y por eso dividimos estas tablas, o por eso dividimos los datos más bien en estas tablas diferentes. Porque de lo contrario obtendríamos una mesa realmente grande. Porque imagina si tenemos nuestro registro de eventos y para cada evento individual, también
almacenamos toda la información sobre el usuario así como la información sobre el evento en sí. Eso significa que cada registro va a tener muchos duplicados porque la información del usuario no va a cambiar y la información sobre el evento no va a cambiar. Y así una forma mejor y más eficiente de estructurar esto es mantenerse al tanto
del registro de eventos y todo lo que necesita que sea irrelevante para este registro de eventos que va a cambiar. Y la información, por ejemplo, sobre el usuario, se puede almacenar en la tabla userinfo. Y todo lo que necesitamos en el registro de eventos es quién hizo el evento. Pero si quieres saber más sobre el usuario,
entonces podemos tener nuestra clave externa, entonces podemos tener nuestra clave externa ID de usuario en
la tabla de registro de eventos, que hace referencia a la clave principal, el ID, y la tabla de información del usuario. Y así ahí podemos obtener una búsqueda directa esencialmente. Y para cada registro, si queremos, entonces podemos obtener más información sobre el usuario y luego lo mismo de los eventos. Entonces de esa manera, podemos usar claves foráneas para hacer referencias entre tablas y vincularlas. Ahora hablamos de la clave primaria, poniendo una restricción en cada mesa, lo que significa que el valor y la clave primaria deben ser únicos en cada fila, necesita ser únicos en cada registro. Pero en realidad también se pueden tener restricciones adicionales. Por ejemplo, otra restricción que podemos querer hacer es que queremos decir OK, el campo de correo electrónico en la tabla userinfo también necesita ser único. Ahora no va a identificar de manera única a la persona, pero queremos que sea único en cada persona. Por lo que podemos tener una clave primaria, por ejemplo, siendo el ID de usuario. Y luego tenemos otro campo, por ejemplo, el correo electrónico. Pero también queremos asegurarnos de que la propia columna de correo electrónico sea única. Y así podemos poner restricciones adicionales en una mesa para decir, por ejemplo, el correo electrónico necesita ser único. O tal vez si tienes una plataforma diferente donde puedes ingresar a través diferentes regiones y tienes un nombre y tienes diferentes regiones, entonces puedes decir el nombre o el nombre de usuario que una persona quiere usar necesita ser único en cada región. Por lo que puedes tener una combinación del nombre y la combinación de región necesita ser única. Para que las personas puedan tener el mismo nombre de usuario en diferentes regiones. Pero en cada región, cada persona sólo se le permite tener un nombre de usuario. Por ejemplo, los nombres de usuario solo permitieron aparecer una vez. Y así, se pueden tener restricciones adicionales a las tablas que van más allá la clave primaria que también requieren singularidad o que también dan como resultado que se pongan más condiciones sobre la mesa. Ahora bien, esto no va a reemplazar la clave primaria, pero va a ser restricciones adicionales además la restricción que necesitamos tener la clave primaria, que cada valor en la clave primaria necesita ser único en cada registro único. Estas restricciones pueden por supuesto ser buenas porque de esa manera, si usted MRF, alguien más tal vez quiera crear una cuenta, pero los correos electrónicos ya se han utilizado por la razón que sea. Y podemos lanzarles un mensaje de error y decir que ya se están utilizando correos electrónicos. Y no vamos a crear registros donde varias personas estén teniendo el mismo correo electrónico. Porque entonces si quieres enviar un email a nuestros usuarios, por ejemplo, en varias personas diferentes están usando el mismo correo por la razón que sea, y eso obviamente va a causar problemas. Y así si hay alguna restricción adicional, como cuántas, ya sea a través de la lógica empresarial o simplemente tu comprensión de cómo deben organizarse todos estos datos, entonces puedes por supuesto poner esos en o en lugar de esas restricciones se pueden poner en las tablas individuales para que, ya
sabes, ninguno de estos problemas ocurra. Ahora con el tiempo, aunque estemos dividiendo nuestros datos en estas diferentes tablas, son tablas todavía pueden llegar a ser muy grandes. Por ejemplo, nuestro registro de eventos puede crecer muy rápidamente si tenemos muchos usuarios usando nuestra plataforma. Y así algo de lo que se puede escuchar es algo llamado partición. Ahora una partición como una forma de que podamos dividir una mesa en sub trozos más pequeños. Y de esa manera los podemos almacenar en diferentes localizaciones. Y esto puede hacer que el almacenamiento sea más eficiente, pero también puede hacer que las consultas sean más eficientes. Por lo general, se hace una partición por una columna que a menudo se usa para filtrar. Entonces, por ejemplo, una forma muy común de particionar datos es por fecha. Porque muchas veces si estás haciendo una consulta, por ejemplo, quieres ver a todos los usuarios activos dentro de la última semana, entonces vas a estar consultando o más bien vas a estar filtrando por fecha. Y así si tu tabla está dividida o más bien dividida en diferentes segmentos, entonces no necesitas pasar por esa cantidad de datos. Solo es necesario hacer referencia a las tablas que realmente contienen los datos apropiados. Y así de esa manera, va a ser más eficiente para el almacenamiento porque no
necesitas almacenar una mesa grande en un solo lugar. Pero en realidad también va a ser más eficiente para consultar porque entonces solo necesitas
pasar por una porción más pequeña de la tabla para obtener los resultados que estás buscando. Ahora lo genial de las particiones es. No te afecte realmente ya que la consulta o las particiones son atendidas por la propia base de datos. Y manejará todas estas cosas de almacenamiento para ti. Y lo hará más eficiente si estás filtrando por las columnas que se utilizan para las particiones. Pero si quieres obtener todos los datos de la tabla, aún
puedes, aunque la tabla se va a particionar, aún
puedes consultar todas las tablas si lo deseas, o puedes consultar toda la tabla que se puede almacenar en diferentes ubicaciones. Entonces a pesar de que las particiones van a estar dividiendo nuestras mesas para hacerla más eficiente. Y pueden hacer que nuestras consultas sean más eficientes si estamos usando los filtros apropiados, aún no va a tener ningún otro efecto negativo en ti o ni siquiera realmente lo vas a notar aparte de los posibles efectos positivos que obtienes de ella. Y así las peticiones son, pues extremadamente cool porque hacen las cosas mucho más eficientes. Aun así no lo hacen, realmente no tienes que interactuar con ellos de ninguna otra manera excepto usarlos a tu favor. Ahora también hay otras formas en que se pueden diseñar bases de datos o
tablas relacionales para que las consultas sean más eficientes. Y eso es mediante el establecimiento de índices o un establecimiento de índices adicionales. Entonces, por ejemplo, digamos que a menudo consultamos por eventos. Es posible que desee configurar un índice adicional para cada evento. Y de esa manera, nuestra base de datos en realidad hará un seguimiento de qué registro tiene qué ID de evento, por ejemplo. Ahora, la indexación va a requerir más almacenamiento. Entonces obviamente no quieres indexar cada cosa porque entonces necesitas hacer un seguimiento de todas esas cosas. Pero en lo siguiente en las columnas correctas puede hacer que la consulta sea mucho más eficiente porque ahora tienes una tabla de búsqueda rápida. Entonces, en lugar de tener que buscar a través de toda la base de datos y encontrar todos los registros, en su lugar básicamente
puedes hacer referencia esta tabla de búsqueda y te dirá qué registros quieres. Por lo que la indexación suele hacerse en las columnas que con mucha frecuencia se utilizan para filtrar. Y puede hacer que las consultas sean mucho más eficientes. Ahora todavía puedes hacer todas las cosas normales sin filtrar en las columnas de índice. Y lo siguiente es solo otra forma para los diseñadores de bases de datos hagan aún más eficiente la consulta de las tablas. Y así por lo general va a ser que las columnas que muy a menudo se usan para filtrar van a ser índice. Y así eso va a hacer que las consultas sean mucho más eficientes. Y así si sabes cuál de las columnas está indexada, entonces cuando quieras hacer tu filtrado, lo mejor es empezar a filtrar por esas columnas. Y luego de esa manera, en las consultas posteriores que estás haciendo, ya vas a estar necesitando pasar por muchos menos registros porque ya has reducido el tamaño de tu tabla realizando el filtrado. Y así la indexación, al igual que el particionamiento, es algo que sólo puede afectarnos positivamente básicamente como la consulta o porque no necesitamos usarlos. Pero si usamos índices y particiones de tablas correctamente, entonces también puede realmente mejorar el rendimiento de nuestras consultas. Ahora, algo más de lo que también puede estar escuchando como relaciones de mesa. Por lo que hay diferentes formas en que las tablas se pueden relacionar con otras tablas. Una de esas formas como una relación uno a uno. Ahora una relación uno a uno significa que un registro una tabla corresponde a un registro de otra tabla, pero tiene que corresponder sólo a 11 registro en esa otra tabla tiene que corresponder a un solo registro de la tabla original. Por lo que tienes dos tablas si están relacionadas por una relación uno a uno que una fila en cada tabla corresponde a una y sólo una fila en la otra tabla. A continuación, tenemos una relación de uno a muchos. Un uno-a-muchos significa que una fila de una tabla corresponde a muchas filas o varias filas al menos. Y otra mesa. Y múltiples filas en esa otra tabla pueden corresponder a una sola fila de la tabla original. Entonces, por ejemplo, o userinfo y nuestro registro de eventos están relacionados por una relación
uno a muchos, una fila y nuestro UserInfo puede corresponder a muchas filas y el registro de eventos, ya que el usuario puede realizar múltiples eventos. Por lo que podemos tener múltiples registros que todos tienen el mismo ID de usuario. Pero cada uno de esos registros sólo hace referencia a una fila o a un registro en nuestra tabla userinfo. Y la información del evento y el registro de eventos tienen la misma relación. Por último, también podemos tener una relación de muchos a muchos, lo que significa que múltiples registros en una tabla pueden corresponder a un registro en otra tabla. Y múltiples registros en esa otra tabla pueden corresponder a un registro de la tabla original.
3. Tipos y esquemas de datos: Todo bien. Ahora que
entendemos un poco más sobre las bases de datos
relacionales
y cómo se construyen y cómo funcionan y cómo se ven
en general En esta lección, quiero
repasar los tipos de datos y esquemas. Ahora comencemos
hablando primero de los tipos de datos. Sólo voy a tener una de las mesas que teníamos aquí en nuestra lección anterior
solo para que
tengamos esta cosa visual a la que volver
a referirnos. Si entramos en esta tabla y solo
miramos
algunos de los valores, podemos ver que
hay diferentes tipos de datos representados aquí. Por ejemplo, la columna ID
parece que lleva enteros
o números al menos La columna de nombre
parece que lleva texto, la articulación parece que lleva fecha o alguna
otra información de hora, y luego el correo
electrónico vuelve a ser texto. Cuando estamos definiendo una tabla, lugar de permitir
que cada columna en
lugar de permitir
que cada columna
tome cualquier valor
que quiera, puede tener mucho sentido
para nosotros definir el tipo de datos que esperamos
ver en cada columna. Ahora bien, esto es útil porque
desde una perspectiva externa, se
puede ver rápidamente
qué tipo de datos
debería haber en cada columna y qué
esperas ver ahí. También es bueno porque los
diferentes tipos de datos requieren diferentes
cantidades de almacenamiento. Puede optimizar el almacenamiento
eligiendo el tipo de
datos adecuado para que no
bloquee el espacio de almacenamiento innecesario que no necesita ser utilizado. Esto también puede
ayudar realmente con cosas como rendimiento porque si estás usando los tipos de datos correctos, entonces en realidad, en
la mayoría de los casos, las consultas se van
a ejecutar más rápido en lugar si solo estás
usando un tipo general para todo porque las
operaciones están mucho más bien definidas para lo que
exactamente estás tratando de hacer. Y también es agradable porque
cuando quieres poner nuevos datos o cuando
estás mirando la tabla y
quieres extraer datos de ella, sabes qué esperar. Si
hay algún desajuste, entonces puedes comparar rápidamente
eso o vas a recibir un mensaje de
la base de datos diciendo, has intentado introducir
texto aquí, por ejemplo, pero este campo
requiere un entero o este campo espera tener una fecha o una hora o
algo así. De esa manera, sus bases de datos probablemente
van a permanecer
más consistentes y ser menos propensas a errores
porque es necesario que haya esta verificación de validación para
asegurarse de que lo que esté entrando
es del tipo
apropiado. Ahí, por supuesto, como se pueden
apreciar diferentes ventajas, tanto desde la perspectiva del usuario, como desde la
propia base de datos y desde el punto de vista de la
eficiencia, tanto en términos de memoria, como en términos de rendimiento y rapidez
de nuestras consultas Echemos un vistazo a algunos de
los tipos de datos que
están disponibles para nosotros, comenzando por los tipos de datos
numéricos. Uno de los muy
comunes que
vas a ver es un entero. También hay diferentes
variaciones de un entero. Puedes tener un
número entero pequeño o pequeño y un
extremo grande un entero grande. La diferencia aquí
es la cantidad de espacio que asigna
a cada Se puede ver en el caso entero, tenemos cuatro bytes
en el extremo pequeño, tenemos dos bytes en el
extremo grande, tenemos ocho bytes. Podemos ver aquí
ya aquí podemos tomar
decisiones que
afectarán el desempeño. Por ejemplo, si
tenemos una base de datos que está puntuando los puntajes de las pruebas, tendría sentido usar
un número entero pequeño porque puntajes de las
pruebas, pero probablemente no
pueden ir por encima de 100. Mientras que si quieres almacenar grandes cantidades de números enormes, entonces puede tener sentido
usar enteros grandes De lo contrario, sus números
van a ser
cortados en algún momento y no
podrá hacerse más grande. Dependiendo de lo que
esperes de los datos, en realidad
puedes
tomar las
decisiones adecuadas para asegurarte de que no
estás
usando innecesariamente memoria extra Después hay,
por supuesto, también otros tipos. Hay
otra llamada numérica u otra variación de
esto sería decimal. Eso solo significa que tenemos
tanta precisión como queremos. Este tipo de datos no tiene un número establecido de bytes asignados
a él y es variable. Esto, por supuesto, lo
hace mucho más flexible desde la perspectiva del
usuario, pero también un
poco menos eficiente desde la
perspectiva de la base de datos porque no puede asignar
cantidades específicas de datos para cada tipo de datos o para cada valor que va
a entrar en cada registro. Ahora, también tenemos algo llamado real y
doble precisión. Ambos se utilizan para
almacenar números decimales. Pero lo real puede llegar
hasta cinco decimales, mientras que la doble precisión puede llegar hasta 15 decimales. Nuevamente, dependiendo
de la precisión que necesites, puedes usar el real
si después de cinco decimales, realmente
ya no
importa, o si realmente te importan
esas cifras decimales adicionales, entonces puedes entrar en doble
precisión, por ejemplo,
para asegurarte de mantener
toda esa información. Entonces otro tipo de datos numéricos que podemos establecer
se llama cereal. Nuevamente, aquí tenemos
la opción de usar ya sea cereal pequeño o también cereal
grande o simplemente normal. Qué es el cereal, es un incremento
automático. Esto es realmente agradable
si queremos tener una columna adicional
para una clave primaria, pero esa columna no está
específicamente establecida. Simplemente sería un
contador de números que está incrementando. El serial en realidad incrementos
de auto. Por ejemplo, si queremos
tener una clave primaria que simplemente seguimiento del número de fila
o algún identificador único, entonces podemos darle el
tipo serial porque se incrementará automáticamente y en realidad no
necesitamos pasarle ningún valor
adicional Simplemente se asegurará de
que siga incrementando desde el valor anterior
que tenía antes También puede tener las
opciones, por supuesto, entre el cereal pequeño y el cereal grande versus también
solo el cereal normal. Nuevamente, solo
dependiendo de la cantidad de datos que
esperamos
tener en nuestra base de datos. Ahora la siguiente
categoría de tipo de datos son los datos de tipo de texto. Hay un tipo de datos llamado texto, que es similar
al tipo de datos numéricos o decimales
que teníamos antes, que solo permite cantidades
variables de datos. No es una cantidad fija, pero puede variar de nuevo
en función de lo que sea el insumo. Pero también tenemos opciones
para tener, por ejemplo, char o carácter,
y luego
definimos realmente cuántos bytes
queremos asignarle. Lo que esto hace es si decimos, por ejemplo, char 25, eso significa que vamos
a asignar 25 bytes a cada registro individual
para esa columna. Si no subimos a 25 bytes, entonces vamos a tener
algo de relleno y de lo contrario, nos van a cortar a los 25. Ahí nuevamente, podemos establecer restricciones de tamaño de
datos
en función de lo que estamos esperando. Entonces también tenemos
la opción de usar un var char o un carácter
variable, lo que solo significa que podemos
subir a tantos tipos de este. Nuevamente, para todos estos,
podemos almacenar datos de texto, pero la cantidad de
memoria que estamos usando para cada registro que
vamos a poner o para cada valor en el registro en una
columna específica que vamos a poner va a variar dependiendo del
tipo de datos que elijamos aquí. Ahora, hay algunos tipos de datos
adicionales específicos a la fecha y hora. Tenemos opciones de marca de tiempo, que solo va
a ser marca de tiempo,
pero también tenemos una marca de tiempo TZ, y de hecho las tenemos
en otros lugares también, donde podemos ¿Elegimos usar la
marca de tiempo con zona horaria? Eso también va a
aumentar de nuevo la cantidad de almacenamiento que necesitamos para
cada elemento ahí dentro. Entonces podemos tener
un tipo de datos de fecha, que es menor que la marca de tiempo porque
ahora solo necesitamos preocuparnos por la fecha y no información extra
sobre las horas,
los minutos o segundos o
incluso milisegundos incluso milisegundos si eso es algo
que estamos La fecha, entonces otra vez, depende de cuánta
precisión
queramos en nuestra información de tiempo. ¿Estamos tratando con fechas
y es suficiente precisión de fecha, o necesitamos
marcas de tiempo específicas, por ejemplo Sabio, también podemos
lidiar con el tiempo, que de nuevo es una
forma de almacenar la fecha, pero además de la fecha, entonces también
podemos almacenar el tiempo. Aquí nuevamente, tenemos la
opción de usar también la zona horaria. Pero si usamos zona horaria, entonces nuevamente
vamos a requerir más almacenamiento de datos porque nuevamente, necesitamos almacenar esa información extra de zona
horaria. Ahora, por lo general, si
no estás usando zona horaria, la zona horaria predeterminada a usar
va a ser la hora UTC. La mayoría de las veces
para guardar almacenamiento, puedes usar la hora o la
marca de tiempo sin una zona horaria y solo asegurarte de
que todos los datos que estás ingresando estén en
hora UTC Finalmente, también hay otro tipo de datos
genial
llamado intervalo, que como su nombre
realmente sugiere, representa intervalos
entre diferentes tiempos. Esto puede ser realmente
útil porque nos
permite hacer cálculos
basados en el tiempo. Por ejemplo, mirar hacia atrás
una semana o ir una semana adelante o ir a mañana
o dentro de la última hora. El intervalo es
otro tipo de datos, eso es muy genial de usar. Como verás cuando lleguemos a la sección diurna en la
redacción de las consultas SQL. Esto también puede ser muy
agradable en las consultas en sí. Bueno, hay algunos tipos de
datos adicionales que tenemos. Uno de ellos es booleano. Este es un tipo de datos muy pequeño, y todo lo que estamos
almacenando aquí es información sobre verdadero o falso. Esto puede tomar solo dos
valores, dos o false. Tenemos el dinero, que se
puede utilizar para la moneda, tenemos el byte A, que
se puede utilizar para almacenar cadenas de
bytes. Hemos enumerado, que es solo un tipo de datos personalizado
que podemos crear Donde podemos asignar una serie de elementos o una serie de objetos y podemos asignarles
un orden. Por ejemplo,
podemos usar enumerar para enumerar los diferentes
meses del año De esa manera, podremos
comparar el orden de los meses. Por ejemplo, podemos decir usando un tipo de datos enumerador que
abril viene después de marzo Mientras que si solo
almacenáramos
eso como información de texto, no podríamos hacerlo. El enumerado es un
tipo de datos personalizado o definido por el usuario que podemos crear, donde podemos dar un
orden específico a los objetos Ahora. Una extensión de esto sería
simplemente tipos de
datos generales definidos por el
usuario donde realmente podemos definir nuestros propios tipos de datos, y luego usarlos
en nuestra tabla misma. Ahora, a medida que se desarrolla postgres o generalmente a medida que se desarrollan
las bases de datos relacionales, también
hay otros tipos de
datos personalizados que se
introducen que pueden no ser inicialmente naturales
para el sistema Algunos ejemplos son,
por ejemplo, JS, XML, matrices, búsquedas de
texto, UUID, datos
geométricos
o tipos de datos de red Todos estos son básicamente tipos de datos de
extensión que entran porque
puede hacer que sea muy útil poder almacenar
este tipo de datos porque cada vez
es más común
que aparezcan estos tipos de datos. Poder poner
eso en una tabla en
una base de datos relacional
puede ser muy agradable Pero nuevamente, estos son tipos de
datos personalizados que son extensiones. medida que crece el tiempo, es
probable que también
haya más tipos de datos personalizados
que estén disponibles para usar. Dependiendo también justo de lo que
la situación requiera. Como puede ver,
hay una gran variedad de tipos de datos que
realmente están disponibles para nosotros. Pero generalmente, los tipos de datos que vas
a ver van a enfocarse más en los tipos de datos
básicos. Solo ser consciente de qué tipos de
datos están disponibles
y también de lo que representan puede ser
muy agradable porque cuando estás
pasando y estás tratando de entender una tabla, solo
reconocerás
esto y también si
tal vez tienes que tomar una decisión
sobre la creación de una nueva tabla, entender qué opciones
están disponibles para ti y tal vez incluso
ser capaz de pensar una un poco sobre cómo puedo optimizar la eficiencia
asegurándome usar el tipo de datos correcto y también asignando la
cantidad correcta de almacenamiento de datos para ello Ahora bien, la otra cosa de la
que quiero
hablar son los esquemas Ahora bien, en general, cuando
te refieres a esquemas, eso suele significar que
tenemos un esquema que representa una colección de tablas así
como información sobre
cada una de las tablas Pero también es común
usar la palabra schema para definir las propiedades y
estructuras de una tabla misma. Por ejemplo, veamos
esta consulta SQL en realidad
en la parte inferior izquierda, pero no te preocupes
demasiado por la consulta. Solo veamos los elementos que hay
en su interior. Lo que podemos ver aquí
es que tenemos un ID, que es un
tipo entero que también se puede acortar para t Podemos ver
que es la clave primaria,
y podemos ver que
tampoco está permitido tomar
valores nulos. y podemos ver que
tampoco está permitido tomar
valores nulos Lo que estamos haciendo aquí
es que solo estamos definiendo nuestra tabla de información de usuario en
el lado derecho. Podemos ver aquí nuestra tabla de ID actualmente
está definida para
llevar tipos de datos enteros. También se define como la
clave primaria, y tampoco se le permite
llevar valores nulos. La siguiente columna que tengamos
va a ser el nombre. Aquí hemos decidido usar
el tipo de datos Varchar, lo que significa que en este caso, le
hemos dado 25 bytes, lo que significa que asumimos que nuestros nombres no van
a ser mayores de 25 porque esa es la
cantidad de almacenamiento que hemos asignado a cada elemento que vamos a poner
con cada registro Se unió aquí va a
ser un tipo de datos de fecha, porque si
miramos la columna, realidad solo
estamos
almacenando información de fecha, no
estamos almacenando información de
tiempo adicional. Para que el almacenamiento sea un
poco más eficiente, no
necesitamos almacenar ninguna información adicional sobre la hora, solo sobre la fecha. Si queremos almacenar información
adicional
sobre la hora, por supuesto, no se
nos permite
usar el tipo de datos de fecha porque eso no
llevaría suficiente información. Por último, tenemos
el campo de correo electrónico. Aquí decidimos usar
el tipo de datos de texto porque los correos electrónicos pueden tener enlaces
muy variados. También es importante
asegurarse de que los usuarios tengan correos electrónicos. Si un usuario se registra con
un correo electrónico y tiene un correo electrónico muy largo o
un correo electrónico muy corto, es
difícil predecir
cuánto tiempo los usuarios pueden
hacer sus correos electrónicos. Ahora podríamos hacer algunas
suposiciones al respecto. Pero claro, no queremos que
un usuario ingrese su correo electrónico. Entonces nuestra base de datos
diciendo que no tenemos suficiente almacenamiento asignado para que
esto almacene el correo completo. Entonces aquí, decidimos
usar el tipo de datos de texto, pero también puedes hacer de esta
una decisión más educada. Si ya tienes datos sobre un montón de usuarios y
un montón de correos electrónicos, puedes ver cuán grandes van
estos correos electrónicos y
luego tal vez dejar
algo de espacio extra de relleno y luego espacio extra de relleno y luego usar algo así como un tipo de datos
varchar Lo que puedes ver en la
parte inferior izquierda aquí es básicamente la
definición de esquema de nuestra tabla. Se puede ver qué
es cada columna y qué
tipo de datos lleva. Podemos ver aquí a partir de esta consulta, solo información sobre
nuestra mesa en sí. Sabemos que tiene cuatro columnas, el ID, el nombre, la articulación en el correo electrónico, y también conocemos el
tipo de datos de cada columna, que significa que también sabemos qué valores esperar
de cada columna, así
como si
queremos insertar valores, qué valores se deben
colocar en cada columna. Echa un vistazo a otra mesa, específicamente nuestra tabla de registro de
eventos. Aquí un esquema va
a ser un poco diferente y
tenemos la clave de evento, que aquí va a ser
un tipo de datos serie porque la clave de evento solo va a estar incrementando con cada evento Si esperamos una gran cantidad
de datos porque tenemos
una plataforma muy grande, tal vez incluso queremos
usar el gran serial aquí. La clave de ventilación va a
ser una clave primaria. Nuevamente, no está
permitido que sea nulo. Entonces vamos a tener
la columna de ID de evento, que va a ser un entero. Puedes ver aquí,
comparando también con la columna de
ID de usuario a continuación, podemos usar tanto in como integer. Es solo una taquigrafía
de entero. Nuevamente, estamos diciendo que no se permite que el
ID del evento sea nulo. Entonces tenemos el tiempo, que en este caso es en realidad
una marca de tiempo. Podemos ver aquí que
tenemos información de tiempo, pero esta es una
marca de tiempo como formato, y así queremos
asegurarnos de que usamos el tipo, y luego
tenemos el ID de usuario, que de nuevo va
a ser un entero. Nuevamente, vamos a decir
que no está permitido que sea nulo. Ahora bien, aquí lo que
también estamos haciendo es que estamos definiendo nuestras dos claves foráneas, ya que nuestro registro de eventos
tiene dos claves externas. Podemos ver el
ID de usuario en nuestro registro de eventos, hace referencia a la columna ID
en la tabla de información del usuario. Podemos volver a ver, solo
desde el enlace aquí. En nuestra tabla de información de eventos, tenemos el ID de evento en
la tabla de registro de eventos, hace referencia a la columna ID
en la información del evento. Entonces podemos ver desde la
consulta en la parte inferior izquierda, pero también la
definición de esquema de nuestra tabla, entendemos que nuestra tabla de registro de
eventos nuevamente, tiene cuatro columnas, la clave de evento, el ID de evento, la
hora y el ID de usuario. También conocemos el tipo de
datos de cada uno. Sabemos cuál es la clave primaria, y también entendemos los enlaces de clave externa
para nuestra columna de ID de usuario, así
como el ID de
evento y qué columnas hacen referencia
en las otras tablas. Entonces sí, así es como podemos definir los esquemas de
las tablas individuales Pero esto también es si estás
leyendo la información sobre una nueva tabla que quizás
solo eres alguien más allá de tu nueva
tabla que puedes usar, puedes mirar la definición de
esquema de la tabla para entender
qué columnas están disponibles, pero también qué tipos de datos y cómo se almacenan así como
qué referencias hay. Nuevamente, no te preocupes
demasiado por la consulta porque eso es lo que vamos a
aprender muy pronto. Solo ten en cuenta que
así es como
podemos definir los esquemas
de nuestras tablas, y esto también es lo que
significan
las definiciones de esquema para nuestras tablas para que podamos definir
correctamente
nuestra tabla como un todo, así
como los tipos de datos
asignados correctamente, así
como los tipos de datos
asignados correctamente, lo que puede ser genial para que la base de datos en sí misma
se asegure de que
también haga almacenamiento de memoria eficiente y esto también es lo que
significan
las definiciones de esquema para nuestras tablas para que podamos definir
correctamente
nuestra tabla como un todo, así
como los tipos de datos
asignados correctamente,
lo que puede ser genial para que
la base de datos en sí misma
se asegure de que
también haga un almacenamiento de memoria eficiente
como hacer que las
consultas sean más eficientes. Pero también es genial
desde la perspectiva del usuario porque entendemos qué
datos se supone que van a entrar, qué datos podemos esperar, así
como qué enlaces puede
haber entre diferentes tablas y cómo están vinculadas
estas tablas.
4. [Mac] configurar un servidor PG local: Ahora vamos a
empezar a ver cómo podemos hacer que PostGress se ejecute en nuestra
máquina para que
podamos empezar a usarlo realmente Ahora bien, si estás en una
empresa o algo así, va a ser
muy probable que tu base de datos esté en línea en alguna parte, así que tendrás detalles de
conexión. Pero aquí vamos a
aprender cómo podemos
configurar un servidor local al que
conectarnos para bases de datos para que
podamos seguir adelante y mantener todo
en nuestra máquina local. Entonces si estás trabajando
con una base de datos diferente, entonces todo lo que vas
a tener que cambiar solo las conexiones
que veremos en los siguientes videos. No hay mucho más en eso, dependiendo de qué base de datos
vas a usar, entonces
vas a necesitar
conectarte a una fuente diferente. Pero ahora veamos cómo podemos hacer que esto funcione
en nuestra máquina local. Vamos a ir
a postreql.org. Entonces una vez que estemos aquí,
vamos a presionar
el botón de descarga aquí para
ir a la sección de descargas. Ahora, dependiendo de tu sistema
operativo, querrás asegurarte elegir el
paquete adecuado para eso. Estoy en Mac, así que voy
a dar click en macOS. Y luego me voy
a desplazar
aquí abajo hasta la app PostGress Esta es una
aplicación interactiva visual muy agradable y
fácil de usar que podemos usar. Voy a dar
click aquí, lo que me
va a llevar a esta página. Entonces voy a
dirigirme a las descargas, y luego simplemente haga clic en el botón de
descarga aquí, y luego eso va
a iniciar su descarga, que luego podrá usar para obtener el archivo que necesitamos para
realizar la instalación. Una vez finalizada la descarga, sólo
voy a
abrir el archivo resultante. Y luego solo voy a tomar este ícono de post grass y bueno, los estándares de
Mac lo
arrastran a la aplicación. Entonces también puedo una vez
que haya terminado de copiar, abrir mi carpeta de aplicaciones, y podemos ver aquí
que solo está instalando. Entonces para abrirlo,
todo lo que tengo que hacer es simplemente hacer doble clic aquí. Entonces nos va a
abrir la postgresa que podamos usar
para
alojar nuestro servidor local Haga clic en abrir aquí también. Si es la primera
vez que
lo abres , entonces aquí vamos. Así es como va a verse tu
cliente visual. También vas a
tener un pequeño icono que viene con él aquí arriba. Entonces si queremos
iniciar un servidor local, solo
tenemos que empezar por aquí, y luego se puede ver que
ahora tenemos un servidor en ejecución. Por defecto, solo vas a tener tres bases de datos
en tu máquina, una con tu nombre para la
computadora que has configurado, una llamada Postscri Luego otra llamada plantilla
uno Se trata de tres
bases de datos distintas que
ahora se configuran para nosotros en nuestra máquina, a las que podemos acceder. Lo importante es que
tenemos que asegurarnos de que
si estamos usando una de
estas bases de datos nuestro servidor
aquí está realmente funcionando. Porque si hacemos clic en detener, entonces ya no podremos conectarnos
a él. Si tienes problemas de
conexión, solo asegúrate de verificar que tu servidor esté realmente funcionando y que el nombre de la base de datos que también
estás usando sea correcto. Entonces el siguiente video
es en realidad mostrarte cómo podemos conectarnos
a estas bases de datos. Ahora, también puedes gestionar
esto desde el ícono de aquí arriba. Se puede ver que también podemos simplemente
parar o servidor aquí arriba. Si queremos, también podemos cotizarlo
completamente desde la barra de menú así como simplemente citarlo desde
nuestra aplicación Pero sí, te recomiendo que solo dejes esto encendido mientras estás
pasando por el curso, solo para asegurarte de que
siempre vas a tener
acceso a la base de datos.
5. [Windows] Servers Postgres Local: Ahora echemos un
vistazo a cómo podemos instalar nuestro
servidor Post Gress en Windows. De nuevo, vamos a dirigirnos
al postgres o aquí. Entonces vamos a ir
a la pestaña de descargas, que actualmente podemos
acceder ya sea
aquí arriba o simplemente haciendo clic
en el botón de aquí. Entonces vamos a dar
click en Windows aquí. Entonces aquí arriba, vamos
a descargar el instalador, que va a ser para versión 12, que es
lo que queremos aquí. Vamos a descargar
el instalador de Windows para la versión 12 actualmente. Entonces solo guarda esto
y deja que se descargue. Ahora, una vez que se
haya descargado, vas a
querer abrirlo. Voy a ejecutarlo aquí
como administrador, y luego vas a decir,
aquí, luego una vez que nuestro
instalador esté abierto, podemos simplemente
seguir adelante e ir a él, y vamos a pasar la configuración aquí, así que
vamos a hacer clic en siguiente. Elige dónde instalarlo. Sólo vamos a dejar todo marcado
aquí, haga clic en siguiente Nuevamente, solo deja todo
en la posición predeterminada. Ahora necesitamos
proporcionar una base de datos, una contraseña para nuestra base de datos, y es importante que
recuerdes esto. Podemos ver aquí nuestro usuario
va a ser posts. Sólo voy a usar
los postgres de contraseña para ambos Pero claro, puedes configurarlo
a lo que quieras. Pero voy a tener mi
contraseña aquí igual
que el nombre de usuario solo
por simplicidad ya que esto es algo local de todos modos. Entonces sigue adelante y haz clic en siguiente. Deje el
puerto predeterminado aquí como 5432, y continúe y haga clic en siguiente Nuevamente, voy a
dejar que esto sea el predeterminado aquí y haga clic en siguiente y luego siguiente aquí y luego simplemente inicie el proceso de
instalación. La configuración está terminada, entonces
solo llegarás a la pantalla de
finalización. Te preguntará si solo
quieres
lanzar stack builder ahora mismo. No tienes que hacerlo.
Puedes llevarte esto. Si dejaste marcando y
acertaste a terminar como reacción, entonces también puedes simplemente
hacer clic en cancelar o cerrar en la siguiente
aplicación de creación de pila que se abra No necesitamos usar eso.
Simplemente puedes golpear acabado aquí. Ahora para entrar en nuestro panel de administración, vamos a entrar en
nuestra función de búsqueda. Vamos a
buscar PG Admin. Aquí tenemos el formulario de administración PG. Abre esto. Una vez que esté abierto, lo va a abrir en un
navegador como podemos ver aquí. Ahora, iba a
pedirnos que solo fijáramos una contraseña maestra para post Cris Admin. Sólo voy
a establecer una contraseña aquí. Esto no tiene
que ser
lo mismo que configuraste durante la instalación, pero asegúrate de
tomar nota de
las dos contraseñas que se usan
aquí. Entonces puedes golpear Bien. Entonces podemos ir por
ejemplo, al navegador. Ahora bien, si queremos
mirar al servidor postgress, que es lo que hicimos durante
la instalación postgress Ahora vamos a necesitar usar la contraseña que establecemos durante
el proceso de instalación, no la contraseña maestra
que acabamos de crear aquí, sino la o la contraseña que
usábamos cuando estábamos
pasando por la instalación. Recuerda, utilicé la
contraseña postgress aquí ya que nos estamos conectando
con el usuario postgres Voy a poner aquí la
contraseña que configuré durante el
proceso de instalación que hicimos o que
pasamos por hace un par de minutos, pulsa Bien. Y entonces podemos ver aquí, ahora tengo básicamente acceso a la base de datos post Postgres
en el servidor aquí También puedes ver que solo
entrando en la pestaña aquí, tenemos esta
opción también, donde podemos, por ejemplo, si quieres
abrirlo en una nueva ventana, que es lo que tenemos aquí. Pero así también es como puedes
meterlo en tu barra de tareas, y aquí en realidad
tenemos entonces la base de datos, que también es lo que
exploraremos un poco más adelante. En casos posteriores, cuando también
solo queremos conectarnos a nuestra base de datos Postgres o al
servidor Postgres local que tenemos, asegúrate de usar el mismo nombre de usuario y contraseña que configuraste
durante la instalación Veremos más adelante cuando veamos el agarre de datos, por ejemplo, para el caso de MAC, en realidad no necesitamos establecer o proporcionar un nombre de usuario y contraseña porque no
configuramos uno. En el caso de Windows, nuevamente, para el ejemplo de agarre de datos
que veremos pronto. Asegúrate de usar el usuario Postcres como lo hicimos aquí
para conectarte al servidor, y luego asegúrate de
usar la contraseña que estableces durante el proceso de
instalación, no la contraseña que estableces aquí
la contraseña maestra, sino la contraseña que estableces durante el proceso de instalación, que es la misma que también
ingresamos aquí cuando nos preguntaron cuando intentamos
entrar en el servidor. Nuevamente, el
nombre de usuario va a ser Postcre y luego la
contraseña va a ser la
que establezca durante
el proceso de instalación
6. [Mac] Configuración de postico: Este video, aprendamos cómo
podemos conectarnos realmente a nuestra base de datos y comenzar a
escribirle consultas SQL. Si estás en una Mac,
hay una interfaz genial que puedes usar para
conectarte llamada postco. Esta es solo la página de descarga en la
que estuvimos
desde la última vez. Si estás en la
pestaña de introducción y te desplazas hacia abajo, entonces puedes ver aquí
un enlace a postco. Ya
lo abrí en una nueva pestaña aquí. Entonces solo puedes descargar
esto y dejar que se detenga localmente. Entonces si quieres
abrirlo, entonces podemos dirigirnos aquí y esto es lo
que vas a ver. Actualmente, no
tenemos o no estamos conectados a ninguna base de datos. Pero vamos a
pasar por la configuración. Esto va a ser
lo mismo
dependiendo de las otras plataformas
que también veremos. Pero vamos a
repasarlo aquí también. Podemos darle un apodo
a nuestra base de datos. Esto es solo para que entendamos
lo que estamos viendo. Aquí podemos decir, por ejemplo, mi primer DB o si quieres darle
un nombre más específico, claro, puedes alojar aquí va a
ser nuestro anfitrión local. Queremos quedárnoslo. Nuestro puerto
va a ser el puerto 5432 Es importante que también
nos quedemos con eso. Si también volvemos
a las postcras, esto también va a estar
funcionando en el puerto Es importante que solo nos
aseguremos de mantener lo mismo. Usuario, también podemos mantener lo mismo. No se requiere contraseña porque la estamos ejecutando
en un host local. La base de datos que podamos
conectar a la predeterminada
simplemente va a ser el
nombre del usuario, que tenemos aquí. Si vamos a nuestros postgres, también
podemos ver que
esa base de datos existe Pero también podemos ver que
tenemos diferentes opciones, por
ejemplo, la de
Postgres aquí, así
como la de plantilla Puedes conectarte a cualquiera de estos. Voy a conectarme
a la plantilla uno. Si no pones nada
aquí, solo va a usar los valores predeterminados
que tiene aquí dentro. Una vez que estemos listos, solo
podemos hacer clic en Listo. Ahora que tenemos la configuración de la conexión a la
base , sólo
podemos hacer clic en Conectar aquí, y luego vamos a conseguir esta nueva ventana abierta para
nosotros, donde
podemos ver, podemos entrar en el
editor de consultas consulta SQL, y aquí podemos entonces
escribir nuestras consultas. También podemos ver por
la barra de menú aquí arriba, con
qué base de datos estamos
conectados. Ahora mismo podemos ver que estamos
conectados con la plantilla uno. Pero si en realidad solo hacemos clic en
segundo plano mi primer DB, que es el apodo que le
hemos dado a nuestra base de datos, vemos que el
servidor al que estamos conectados en realidad
tiene tres bases de datos. Si queremos, también podemos
conectarnos con los diferentes. Podemos ver aquí ahora estamos
en mi base de datos de nombre de usuario, o podemos salir y
podemos entrar en plantilla uno o podemos salir y
podemos entrar en la base de datos
Postgres Se puede ver para cada uno de
estos, entonces también podemos abrir el editor de consultas y
dependiendo de la base de datos en la que nos encontremos. Bueno, ese va a ser el que estemos
conectados
y al que le estemos
escribiendo consultas. Si queremos crear
una nueva base de datos en su servidor
o en nuestro servidor, también
podemos hacerlo simplemente
haciendo clic en el botón de base de datos aquí, y luego podemos darle un nombre a
nuestra base de datos si queremos o para eliminarla, simplemente
podemos hacer clic en Eliminar aquí, y luego simplemente escribimos drop database y eso
eliminará esa base de datos. Si queremos volver a la opción donde realmente lo
conectamos a esta base de datos,
podemos entrar en archivo,
mostrar ventana de favoritos, y luego eso va a tener la ventana original donde nos
conectamos a nuestra sala de
base de datos. Quiere configurar cualquier conexión
adicional, entonces puede crear
un nuevo favorito, recomiende simplemente desconectarse
de esta primero Actualmente, estamos
en el juicio de honorarios. Si quieres crear
nuevas conexiones aquí, entonces puedes crear
un nuevo favorito y luego va bien, entonces puedes configurar opciones de
conexión adicionales. Puedes tener uno, por ejemplo, tu
lado local con el que
quieras jugar. Si tienes uno en el trabajo
o en algún otro lugar, entonces también puedes
conectarte a estos aquí. Como puedes ver, cuando
estemos descargando postco, vas a hacerlo por defecto
en la versión de prueba La versión de prueba es
gratuita, indefinidamente. Simplemente tiene un
número reducido de características. Pero para cualquier propósito
y propósito, servirá muy bien. Pero claro, si quieres activar, entonces
claro que puedes. Pero solo asegúrate de
que revises todos los diferentes o que
al menos revises también
el otro video. Voy a
hablar de un agarre de datos, solo para que
veas las diferentes interfaces de
usuario con las que
puedes lidiar o los diferentes
servicios conexión
o aplicaciones para conexión que
puedes usar para que decidas
cuál es la mejor para ti, cuál te gusta más. Entonces te recomiendo simplemente
quedarte con el que más disfrutes con el que te sientas
más cómodo. Sí,
7. Configuración de Datagrip: Ahora, la siguiente herramienta
que te voy a mostrar para conectarte a bases y hacer todas esas cosas geniales con la
escritura de consultas y todo va a ser un agarre de
datos de jet cerebros. Este es también el que
vamos a utilizar a
lo largo del curso. Puedes obtener esto
yendo a jet brain.com, luego yendo a herramientas, y aquí ir a agarre de datos. Con el agarre de datos, vas
a obtener una prueba gratuita de 30 días, debería estar bien para
pasar por el curso, así
como hacer algunas prácticas
adicionales. Pero si lo disfrutas, entonces
sí tiene una versión paga. Hay, como también vimos con
postco o también otros GYs. Hay, por supuesto, otros
gratuitos que puedes usar, dependiendo de lo
mucho que te guste o también si has jugado
con otros, entonces puedes optar por ir con el grip de datos
o puedes, por
supuesto, elegir también
cualquier otro sistema. Realmente no
importa al final. Todo esto solo va a estar
conectándose a nuestras
bases de datos y esas cosas. Es justo con el que te
sientas más cómodo. Entonces vamos a comenzar
con una prueba gratuita de 30 días. Si quieres seguir
el curso exactamente,
entonces, por supuesto, puedes
obtener agarre de datos aquí. Entonces una vez que caduca tu prueba, puedes decidir
si quieres
continuar con el
agarre de datos o si
quieres usar un GI diferente
que tenga servicios gratuitos, por ejemplo, código postal que
vimos ofrece prueba gratuita de por vida, y ahí solo puedes
seguir usándolo gratis. Eso depende totalmente de ti. Pero adelante y descarga el agarre de datos. Una vez hecho esto, solo sigue
la configuración y ábrela. Ahora, una vez que hayas descargado
un grip de datos abiertos, esto va a esto
cuando lo abras en caso de que no tengas esta
ventana aquí en la barra lateral. Puedes conseguirlo muy
fácilmente entrando a la vista, luego a las ventanas de herramientas y
haciendo clic en la base de datos aquí. Entonces eso solo va
a abrir o cerrar la ventana
del lado izquierdo. Para conectarme a una base de datos aquí, solo
voy a
hacer clic derecho sobre la nueva fuente de datos. Voy a seleccionar
postgresar QL aquí. Esto nos va a permitir
configurar una fuente de datos Postgres Voy a hacer click
en esto, y eso va a sacar a colación esta ventana de
conexión aquí. Si no ves postgresa cuando me dejas
cerrar esto otra vez. Si no ves
postgresas aquí arriba, entonces probablemente solo
va a estar aquí abajo Una vez que
los hayas seleccionado antes, entonces van
a ser trasladados para ti aquí para que
tengas un acceso más fácil. Probablemente no va
a estar aquí arriba para ti si nunca antes has usado el grupo de
datos, en cuyo caso,
estaría aquí abajo en alguna parte. De todos modos, adelante
y ábrelo, y eso nos va a dar nuestra ventana de conexión postgresa Aquí de nuevo, podemos
dar un apodo. Entonces podremos tener nuestras opciones de
conexión. Nuestro anfitrión seguirá siendo
el anfitrión local. Nuestro puerto todavía
va a ser el puerto 5432. No necesitamos un nombre de usuario o contraseña para recopilar en
la base de datos local. Entonces la base de datos a la que
queremos conectarnos, podemos elegir entre,
por supuesto, Postgress nuevamente O si solo abrimos nuestra app Postgress,
también tenemos, por supuesto, Temple one, así como el nombre de usuario de cualquier
computadora que estés usando Simplemente entonces podemos hacer clic en Bien. Y eso nos va a conectar a una base de datos, y
podemos ver aquí, también
obtenemos una consola con ella donde realmente podemos
escribir nuestras consultas SQL en. Si queremos, también podemos explorar base de datos abriéndola, y luego podemos ver
la estructura aquí. Ya hay una base de datos
configurada en ella por defecto. Pero aún no hay mesas en él. Aprenderemos más sobre
esto un
poco más adelante una vez que nos metamos
en todo esto. Pero así es como
podemos conectarnos a la base de datos Postgres
utilizando el grupo de datos En caso de que accidentalmente alguna vez
cierre su consola aquí, puede volver a
abrirla fácilmente haciendo clic derecho sobre aquí, y luego abrir la consola de consultas. Ahora, algo tan genial
sobre el agarre de datos es que en realidad
podemos tener varias conexiones de
base de datos abiertas. Por ejemplo, voy a agregar otra nueva fuente de
datos aquí, y voy a agregar aquí
otra fuente de datos postgres, y ahora también vamos a
conectarnos a la plantilla uno Nuestra configuración aquí
todavía va a decir lo
mismo todavía va a estar en el host
local todavía
va a estar en el puerto. Nuestro apodo aquí solo
va a ser llenado en mi defecto, y
luego puedo hacer clic. Ahora podemos ver que
nos estamos conectando a otra base de datos aquí
en nuestro sistema local, que es esta. Aquí. Aquí también podemos ver que también podemos entrar
aquí y explorarlo. La base de datos Postgres
por defecto en realidad tiene algunas cosas más
establecidas en ella. Pero nuevamente,
aprenderemos más sobre eso una vez que realmente nos
metamos en la consulta. Esto es solo más para asegurarnos de
que tenemos la configuración adecuada. También puedes ver aquí
ahora tengo dos consolas. Uno que esté conectado
a nuestros postgres. Nuevamente, este va
a ser nuestro apodo. El otro que es para la base
de datos de plantilla uno. Por supuesto, si cierras alguno o alguno de estos
o todos estos, solo
puedes volver aquí, hacer clic
derecho en abrir consola de consultas, y también aquí podemos
abrir la consola de consultas. Solo quieres asegurarte de que
cualquiera que sea la
consola de consultas que estés usando, quieres asegurarte de que
sea para la base de datos correcta en caso de que tengas
varias bases de datos abiertas Siente que la pestaña de tu barra aquí se está
llenando demasiado. También puedes simplemente volver a hacer
clic en la base de datos, hacer clic
derecho y eliminar, luego eso va a eliminar la configuración
de la base de datos. Una cosa a tener en cuenta al respecto
es que la configuración también se
ha ido. Si quieres volver a conectarte a él, en realidad
vas a tener que seguir los
pasos de
nuevo origen de datos y
luego conectarte a
la fuente de datos y poner
en los detalles de configuración Pero si quieres quitarlo, entonces así es como puedes hacerlo.
8. Conexión CLI: Ahora, la otra opción que
puedes tomar y que
a veces puedes tomar es usar la interfaz de línea de
comandos. Esto solo significa
usar el terminal o algo
así para conectarse. A veces es posible
que desee usar esto. Aunque personalmente prefiero
las interfaces gráficas. Otras veces es posible
que te veas obligado a hacer esto. Si estás,
por ejemplo, conectado a una máquina remota y tienes que
trabajar en la base de datos de ahí, y la única opción que tienes es usar una interfaz de línea de
comandos. De cualquier manera, también puedes usar
la interfaz de línea de comandos. Para nosotros, conectarnos a él
va a ser fácil porque
tenemos nuestro servidor Postgres aquí Podemos simplemente conectarnos o
hacer doble clic en uno de estos, y luego eso va a abrir la conexión en
un terminal aquí, y luego podemos escribir solo
nuestros comandos SQL aquí. Estas son las diferentes opciones
que tenemos disponibles. Vamos a ir con agarre de
datos en este curso. Pero claro, puedes
elegir lo que quieras. Por supuesto, también se puede cambiar entre las diferentes
aplicaciones. Al final del día, no
va a importar mucho
con
cuál vayas porque todos proporcionan
los mismos medios para un fin,
que es conectarse
a nuestra base de datos y dejarnos
escribir nuestras consultas. Cualquiera con el que te sientas más cómodo es con el
que deberías ir, porque al final del
día, básicamente todos nos
van a permitir hacer lo mismo
9. Crear y despegar bases de datos de datos: Ahora que sabemos cómo
conectarnos a una fuente de datos. Sigamos adelante y
aprendamos cómo podemos crear una base de datos dentro
de nuestra fuente de datos. Voy a estar conectándome
a la plantilla,
solo porque no
hay bases de datos ni nada dentro de aquí,
está completamente vacía. Te recomiendo que
hagas lo mismo solo para tener una fuente de datos completamente
nueva. Para ti, incluso puede ser posible que al hacer clic en
esta flecha desplegable, no
veas nada porque normalmente estas carpetas
solo se crean, si creas y luego eliminas
una base de datos después. Para ti, si
haces el desplegable, es
posible que
en realidad nada baje. Ahora bien, en caso de que estés
en la configuración aquí, por ejemplo, te está diciendo
que no
se encuentra la base de datos o no
puedes conectarte a ella. Por ejemplo, si trato de
conectarme a la plantilla dos aquí. Antes de aplicar realmente,
también puedo simplemente probar la conexión. Si intento esto, no va a funcionar porque la
base de datos no existe. En este caso, si quieres
conectarte a una base de datos diferente, pero una opción, por supuesto, siempre
es simplemente conectarte
a la de los POC, que siempre debe incluirse y crearse en cada sistema Los otros suelen crearse
en los otros sistemas, pero puede haber casos
que difieran de un
sistema a otro donde la base de datos puede que no se cree por defecto. Para ello, podemos simplemente conectarnos
a postcras por ejemplo, entonces podemos
usar esto directamente, o podemos entrar en
nuestra consola de consultas, y esto es también
lo que vamos a aprender en la lección que viene, vamos a escribir
crear base de datos, y vamos a crear, por
ejemplo, la plantilla dos, si esa es la que
queremos conectarnos Entonces podemos ejecutar esto y
podemos ver aquí que solo se
estaba actualizando, y vamos a volver
a nuestras propiedades aquí. Ahora si intentamos
conectarnos a la plantilla dos y
probamos nuestra conexión. Vemos aquí ahora está
funcionando correctamente. Esto es solo porque
en el video, voy a estar
usando la plantilla una base de datos en caso de que
no exista para ti, puedes hacer esto para
crearla y luego conectarte a ella. Pero claro, alternativamente también
puede simplemente usar la base de datos
Postgres predeterminada para Pero sigamos adelante y creamos una base de datos porque recuerden, cuando aprendimos sobre
el modelo relacional, tenemos tablas que
están dentro de una base Antes de poder crear tablas, primero
tenemos que tener una base en
la que poner estas tablas. ¿Cómo podemos crear una base de datos? Bueno, aquí, voy a tener
la consola querin abierta. Notarás que esta
es la consola para mi plantilla una conexión de
fuente de datos, como puedes ver por el nombre aquí. En caso de que tenga varias fuentes de
datos abiertas, asegúrese de que está
utilizando la consola adecuada para la fuente de datos correcta. También asegúrate de estar conectado usando tu pasto de correos
para asegurarte de que tu
servidor postgress local esté funcionando Si no lo es,
asegúrate de hacer clic en Inicio. Bien, entonces, ¿cómo podemos crear una base de datos en nuestra
plantilla una fuente de datos? Para ello, vamos a usar o
vamos a escribir en nuestra consola de
consultas aquí, crear base de datos, y luego vamos
a escribir aquí el nombre de la base de datos, que rellenaremos en un segundo. Entonces vamos a
terminarlo con un punto y coma. Hay algunas
cosas importantes a tener en cuenta aquí sobre la estructura general de
consultas SQL. En primer lugar, todos los
comandos SQL suelen ser capitalizados por el usuario solo para que la
consulta sea más legible Además, es costumbre
terminar los comandos SQL
con un punto y coma No necesitas hacer esto,
pero esto indica que la consulta ha terminado y en
realidad puedes encadenar varias
consultas juntas,
cada vez que termines realidad puedes encadenar varias
consultas juntas, una consulta, puedes entonces poner un
punto y coma aquí para decir
básicamente, esta
consulta está hecha Vamos a crear nuestra base de datos, y llamémoslo nuestro DB. Si ejecutamos esto, entonces podemos
ver que aquí conseguimos un consolg. Si entramos en bases de datos, ahora tenemos nuestro DB creado. Este es el nombre de la base de datos
que le hemos dado. Podemos ver aquí conseguimos algunas carpetas
extra que
vienen con él también. Sí. Así es como podemos ir
sobre la creación de una base de datos. ¿Y si queremos
eliminar una base de datos? Bueno tenemos que hacer entonces es
cambiar el create a drop. Entonces si ejecutamos esto,
notarás que ahora nuestra
base de datos se ha ido. Podemos ver que se ha
eliminado de nuestra fuente de datos. Para demostrarle que la
capitalización no es necesaria y tampoco lo
es el punto y coma Sigamos adelante y repitamos la misma consulta que
hicimos al principio. Pero esta vez usar
todo es minúscula, además de no usar el
punto y coma al final Si ejecutamos esto, y aquí vamos,
podemos
volver a abrir nuestra base de datos y todo
vuelve a la forma en que la teníamos. Puedes ver que
aún puedes escribir consultas SQL con todo siendo minúsculas y sin el punto y coma Sin embargo, suele ser
una buena práctica quedarse con el
punto y coma al final, así
como escribir todos los
comandos SQL en mayúsculas Porque de esa manera, es mucho
más fácil leer la consulta. Es fácil distinguir lo que
forma parte de una consulta SQL, y lo que tal vez sea un nombre que aparece en una tabla en
nuestra base de datos que tiene un nombre similar o idéntico a algo que
tendrías en una consulta SQL. Y claro, también
crear una segunda base de datos. Vamos a crear otra
base de datos aquí llamada nuestra segunda base de datos. Vamos a usar algunos guiones bajos
aquí para hacer esta base de datos más legible
o este nombre más legible Si seguimos adelante y ejecutamos esto, entonces verás aquí ahora tenemos dos bases de datos y nuestra
plantilla una fuente de datos. Se puede ver que podemos
entrar en cada uno de estos, y cada uno de estos es
una base de datos separada. Por supuesto, podemos eliminar
estos nuevamente así, y luego también podemos eliminar nuestra primera base de datos usando
el nombre apropiado. Entonces otra vez, llamando a la sentencia
drop database.
10. Crear esquemas: Todo bien. Ahora que sabemos cómo crear y
soltar bases de datos, echemos un vistazo a cómo
podemos crear y soltar esquemas, ya que ahí es donde queremos
poner nuestras tablas dentro de ellas. De nuestra última lección, pudimos crear RDB aquí Pero a veces es posible que en
realidad te encuentres con un error. Por ejemplo, si tecleo aquí, caigo base de datos, y
quiero soltar RDB, me
va a dar un
error porque ya estoy conectado a la base de datos
actualmente abierta Debido a que estoy conectado a él, en realidad no
puedo dejarlo caer. Entonces una cosa que puedes hacer para cambiar esto
sería por ejemplo, entrar en una
opción diferente que tenemos aquí. Vemos que tenemos nuestro DB, que va a estar
en nuestra plantilla uno, pero también tenemos diferentes
opciones para entrar. La otra cosa que
podemos hacer si
realmente queremos dejar caer
una base de datos es, podemos crear una nueva base de datos. Por ejemplo, nuestro guion bajo DB Podemos crear eso, y luego tenemos que cambiar
nuestra conexión, lo que podemos hacer entrando
aquí y haciendo clic en RDB Ahora, supongo, estos
nombres no son particularmente útiles cuando lo
dices en voz alta, pero ahora tenemos dos bases de datos. Uno de ellos tiene un
subrayado en él, que es el que
actualmente estamos conectados, como podemos ver aquí en
la esquina superior derecha El otro no
tiene un guion bajo en él, y no es con el
que estamos conectados en nuestra sesión actual aquí, porque de nuevo,
ese no es el que tenemos aquí arriba en
nuestra esquina superior derecha Esto aquí va a
ser específico de agarre de datos, pero es probable que tengas indicaciones de interfaz de usuario
similares si estás usando diferentes editores
SQL. Si queremos,
podemos, por ejemplo,
ahora dejar caer nuestro DB, ahora dejar caer nuestro DB, ya que ahora estamos conectados a la base de datos que tiene
un guion bajo en ella Si queremos dejar caer la base a la
que estábamos
conectados antes, ahora
podemos soltar base de datos, y luego llamar al nombre en este caso sin el
guion bajo, podemos ejecutarlo Ahora podemos ver que la
base de datos ha sido eliminada. Una cosa que notarás es si entramos en el esquema aquí, realidad no
podemos
ver ningún esquema. Sin embargo, si estamos mirando de
cerca nuestro símbolo RDB aquí, en realidad vemos que
estamos conectados a nuestra base de datos de guiones bajos, que es la base de datos
pública, que es el esquema Si este es el caso, es
probable que reciba esta notificación, que también estoy
viendo aquí arriba desde el agarre de datos donde simplemente podemos
hacer clic en el esquema introspecto Entonces ahora si vamos a nuestro esquema, podemos ver ahora que está
disponible para nosotros. En realidad tenemos disponible el esquema
público. Pero, ¿cómo se puede
crear un nuevo esquema? Bueno, para hacer eso,
tecleamos create schema, y luego simplemente
tecleamos el nombre igual que hicimos
para la base de datos. Por ejemplo, aquí, a
este podemos llamar nuestro esquema, y
podemos ejecutar este. Para mí, ya lo he creado, así que me sale un error
que ya existe. Veamos cómo podemos dejarlo caer. Podemos escribir drop
schema, nuestro esquema. Entonces si ejecutamos esto,
podemos ver cómo se elimina el
esquema. Entonces si queremos,
podemos crearlo nuevo escribiendo create schema, y luego creará
otro esquema para nosotros. Ahora claro, el
nombre del esquema no tiene
que ser así. Puede ser el nombre que
sea más apropiado. Si queremos, podemos
dejar esto otra vez. Por lo general es costumbre o. Por lo general, está bien seguir con el esquema público. No
tiene nada de malo. Si ya tienes
un esquema público que debería estar
ahí por defecto, entonces también puedes
simplemente quedarte con un esquema público y
no preocuparte demasiado. Pero si específicamente
necesitas o quieres
crear esquemas adicionales para
luego agrupar tablas en, entonces por supuesto, ahora sabes cómo y tienes la
opción de hacerlo
11. Crear cuadros: Ahora aprendamos
cómo podemos crear tablas en nuestros esquemas de
base de datos Para ello, la sintaxis
que vamos a usar va a ser crear esta tabla de tiempo, y vamos a
tener nuestro nombre de tabla. Por ejemplo, aquí podemos usar la información del usuario como también
vimos en las lecciones anteriores. Ahora, hay algunas cosas extra
que tenemos que hacer aquí. Queremos abrir y
cerrar paréntesis aquí, y ahora podemos poner
en los nombres reales de las columnas en nuestra tabla así
como qué
tipo de datos llevan Haz que todo esto se vea
un poco más agradable. Voy a llevar esto
por varias líneas. También voy
a poner de nuevo un punto y coma al final aquí solo para
asegurarme de que no lo olvide después. A pesar de
que como ya has visto antes, funciona sin él,
solo es una buena práctica
tenerlo ahí. Vamos a tener nuestra primera columna, el ID, que va
a ser solo un entero. Aquí, vamos a tener esta
nuestra clave principal. Ahora para crear una siguiente columna, vamos a poner una coma
aquí para separar esto Entonces nuestra siguiente columna, hagamos
que este sea el nombre. Hagamos que esto sea un
varchar usando 25 bytes. Al siguiente nos podemos haber sumado. Esta, vamos a tener
la fecha ocho. Podemos establecer su
correo electrónico si queremos, y este podemos,
por ejemplo, ser un campo de texto. Si ejecutamos esto,
podemos ver aquí ahora nuestra tabla de información de usuario ha sido creada dentro
del esquema público. Podemos ver aquí
también si entramos, también
tenemos información
sobre la clave primaria, así
como las columnas que
están dentro o los atributos, así
como los tipos de datos a cada
atributo de alcance de columna que tenemos. ¿Cómo podemos quitar una mesa? Bueno, eso va
a ser mucho más fácil. Sólo vamos a
escribir drop table. Entonces vamos a poner aquí
el nombre de la tabla. Por ejemplo, info de usuario, punto y coma hit run Ahí vamos. Olvídate de hacer clic en ejecutar
y luego solo espera y puedes ver aquí ahora nuestra
tabla ha sido eliminada. Y si tenemos
múltiples esquemas. Vamos a crear un segundo esquema, y llamemos a
éste nuestro esquema de nuevo. Entonces vamos a ejecutar esto. Ahora
tenemos dos esquemas Sólo voy a
volver un rato aquí para
que obtengamos nuestro código
que teníamos de antemano. ¿Qué pasa ahora si ejecutamos nuestra sentencia create table?
Bueno, vamos a probarlo. Si ejecutamos nuestra sentencia create
table, vemos aquí ahora la estamos poniendo
en el esquema público, que también es el que
estamos conectados aquí. Hay diferentes opciones
que tenemos disponibles. Una de ellas es que podemos cambiar
nuestra conexión aquí arriba. Por ejemplo,
conectándonos a nuestro esquema, en lugar del público, y podemos ver aquí ahora nuestra
conexión ha sido cambiada. Aquí podemos volver a crear
la tabla de información del usuario. Esta vez, se va a
crear en nuestro esquema. A veces puede que no tengas el lujo
de cambiar así. A veces puede ser diferente. En otros casos, si
necesita especificar un esquema, también
puede agregarlo
poniendo el nombre del esquema
frente a la tabla real. Vamos a crear otra tabla
aquí llamada user Info two. Déjame arreglar este error tipográfico aquí. Se puede ver a pesar de que estoy
conectado a nuestro esquema, que es el esquema aquí. He creado una tabla de información de usuario dos en el
esquema público como podemos ver aquí. Por supuesto, si elimino
este prefijo aquí, y vuelvo a ejecutar esto,
entonces
se va a crear en el esquema que actualmente estamos
conectados Puedes ver si estás tratando
con múltiples esquemas, entonces
puedes crear ya sea cambiando a ellos y creando
tablas directamente en ellos, o si quieres, puedes hacer
referencia al esquema antemano para luego crear
tablas allí ahora Entonces, ¿qué pasaría ahora que estamos creados
a nuestro esquema, sigamos adelante y
volvamos
al público
entrando en RTB,
entrando en público, golpeando ¿Qué pasa ahora si queremos
dejar de lado el esquema y
queremos dejar caer el nuevo
esquema que hemos creado? Bueno, ahora
vamos a encontrarnos con
un problema porque tenemos
mesas creadas en su interior. Una cosa que podemos
hacer es que podemos continuar y podemos eliminar
todas las tablas dentro, y luego podemos
eliminar el esquema, o como datos Grepard nos
sugiere, podemos usar algo que
se llama cascada al final Podemos teclear cascada aquí. Entonces básicamente solo
realizará esta operación, pero continuará
y hará la limpieza adecuada
también dentro en este caso Si ejecutamos esto ahora, no sólo se
va a eliminar nuestro esquema, sino también todas las tablas
contenidas en su interior. Ahora para limpiar esto aún más. También sigamos adelante y dejemos caer la tabla de información del usuario
dos para que
no tengamos nombres de
tabla extraños que tengan todas las mismas columnas
que estén en conflicto Sigamos adelante y
bajemos esta mesa dos. También echemos un vistazo a cómo
podemos crear las otras
dos tablas que
vimos en la lección solo para que también
podamos
mirar claves foráneas. Aquí podemos volver a
tener crear tabla, y vamos a crear nuestra tabla de información de
eventos, información subrayado de
eventos Aquí vamos a tener
dos columnas en su interior. Uno de ellos va
a ser ID, que de nuevo, podemos ser un entero, y hagamos de esta
nuestra clave primaria. Entonces también vamos
a tener el nombre, que podemos tener un
texto o un varchar, o lo que nos guste, lo que nos parezca apropiado Ahora, una cosa que quiero hacer es que voy a hacer estos nombres mayúscula en vez de minúsculas solo para mostrarte
lo que pasa aquí. Si ejecutamos esto y
entramos en nuestra tabla de información de eventos, podemos ver aquí
que aunque los
creamos con nombres en
mayúsculas, cuando entramos en la tabla, todavía solo
tenemos nombres en
minúsculas aquí Por eso también
es tan agradable usar estos guiones bajos porque incluso si estas conversiones ocurren, todavía hace que sea fácil de leer Sigamos adelante y también
creamos la tabla de registro de eventos. Aquí vamos a
tener nuestra clave de evento, que va a ser serial que sea auto incrementando. Entonces solo mantengamos nuestras dos identificaciones aquí y no nos preocupemos demasiado
por las otras cosas. Vamos a tener un ID de evento, que va a ser un entero. Entonces también vamos
a tener un ID de usuario, que también va
a ser un entero. Entonces si queremos,
también podemos agregarle, por ejemplo, la columna de tiempo, o
podemos llamarlo tiempo en mayúsculas. Esto podemos hacer una marca de tiempo, hagamos esta mayúscula No vamos a
agregar tiempos aquí porque si estamos usando esto, solo usa UTC, y
eso nos va a ahorrar algo de espacio de almacenamiento. Ahora que tenemos
nuestras cuatro columnas, ¿cómo podemos hacer referencia
a las claves foráneas Para ello, vamos
a ir en una nueva línea, y vamos a
decir, clave externa, y tal vez ya
lo recuerdes de las
lecciones de antemano. Vamos a abrir
y cerrar paréntesis. Vamos a poner aquí
el nombre al que queremos hacer referencia
de nuestra tabla, que va a
ser el ID del evento. Vamos a decir referencias. Pero entonces vamos a poner aquí
el nombre de nuestra mesa. Por ejemplo, vent info. Entonces aquí vamos a poner el nombre de la columna al que
queremos hacer referencia. En este caso, el DNI. Nuestro ID de evento va a
ser una clave externa que haga referencia a la columna ID
y a la tabla de información del evento, y haciendo lo mismo
para la información del usuario, vamos a crear
la clave externa, y va a
ser nuestro ID de usuario. Se va a decir referencias a
la tabla de información del usuario, aquí va a hacer
referencia a la columna ID. Si seguimos adelante y ejecutamos esto, y sigamos adelante y
echemos un vistazo a nuestras mesas. Ahora también tenemos la tabla de registro de
eventos. Podemos ver aquí,
tenemos la clave primaria, pero también tenemos referencias de
clave foránea aquí.
12. Alogar: Ahora bien, es probable que con el tiempo
los requisitos de tu base de datos puedan cambiar. Es posible que desee alterar las tablas, es posible que desee
agregarles cosas, eliminarlas o incluso
cambiar cosas dentro. Para ello, podemos usar
el comando alter table. Entonces vamos a poner el nombre de la mesa que
queremos alterar, y luego qué es exactamente lo
que queremos alterar al respecto. Veamos algunos ejemplos. Digamos que también queremos
agregar región a nuestra información de usuario. Nosotros decimos, tenemos su
identificación, su nombre, y cuando se unen a su correo electrónico,
pero
en realidad no sabemos en
qué región se encuentran. En qué parte del
mundo se encuentran. Vamos a decir que
vamos a alterar nuestra tabla de información de usuario. En este caso, queremos
agregar una columna. Vamos a escribir
add. Aquí vamos a tener el nombre de la columna, que va a ser región, y luego queremos tener
el tipo de datos de columna. Esto podemos decir, por
ejemplo, de nuevo, vamos a tener esto un varchar, tal vez de talla 20 o lo que
consideremos apropiado Entonces, claro, también
queremos asegurarnos de poner un punto y coma al final aquí
solo por una buena práctica. Entonces si ejecutamos esto y solo echamos un vistazo a
la tabla de información del usuario, vemos ahora que tenemos la columna
region agregada a ella. Digamos que en algún
momento, nuestra mesa se está haciendo demasiado grande
y nosotros decidimos, la columna región
en realidad no es tan importante. Entonces podemos usar en lugar
del comando drop column. Ahora sólo vamos a poner el nombre de la columna que
queremos dejar caer. Queremos dejar caer
la columna de la región. Puede hacer clic o ejecutar aquí, y luego eso
lo eliminará de nuestra tabla de información de usuario. Digamos que en algún momento, nos damos cuenta de que nuestra
columna de ID se está volviendo demasiado grande, los enteros aquí
se están volviendo demasiado grandes, y necesitamos modificar nuestra
columna para que podamos
encargarnos de ID más grandes porque nuestra base de usuarios está
creciendo muy grande Lo que podemos hacer para
hacer eso es que podemos crear o podemos
decir alter table, queremos alterar la tabla de información del
usuario. Ahora queremos alterar columna. Queremos alterar la columna ID, queremos cambiar el tipo
de la columna ID a, por
ejemplo, una grande. Podemos ejecutar esto. Entonces
puedes ver aquí nuestro tipo de entero ahora se va a actualizar
a un tipo grande. Si queremos,
también podemos revertir esto. Te darás cuenta aquí puedo usar la minúscula así como
la versión en mayúsculas. De esta manera, puedo modificar o alterar columnas que
ya están disponibles. Ahora, hay muchas más
alteraciones que puedes hacer que realmente dependen de
la situación. Dependiendo de
la situación en la que te
encuentres, tal vez quieras
actualizar tu base de datos
o necesites actualizar tu base de datos y quieres
alterar o modificar algo. Um,
lo más fácil de hacer es simplemente hacer
rápidamente un
Google rápido y decir, cómo convierto esto en esto, y luego será exactamente la
misma sintaxis que teníamos aquí. O será
algo que
ya has visto, por ejemplo, alterar tipos de columnas o
agregar o eliminar columnas, o algo muy
similar, por ejemplo, modificar una columna o
cambiar sus restricciones.
13. Tipos enumerados: Entonces echemos un
vistazo a cómo podemos crear tipos de datos enumerados porque a veces
queremos tener o hay un
orden natural a las cosas,
pero es difícil para nosotros tal vez representarlo ante una computadora Entonces un ejemplo fácil de esto es tomemos
los días de la semana, y digamos que hay
un pedido específico, y comenzamos con que el lunes
sea el primer día, y luego podemos ir martes,
miércoles, jueves, viernes, sábado, domingo, o
tal vez quieras comenzar con domingo e ir al sábado o cualquier orden que
quieras usar. Pero tal vez quieras decir
algo como yo solo quiero
buscar casos que
sucedan después del miércoles. Entonces entre miércoles y
sábado o algo así. Usar ese orden
es difícil
porque no es inherente a
las palabras mismas. Lo sabemos porque entendemos el significado de los días de la semana, pero una computadora, por supuesto,
no lo sabe. Una cosa que podemos hacer en SQL es crear un tipo de datos
enumerado, y ahí entonces podemos especificar el orden jerárquico entre estas
diferentes instancias Por ejemplo, para hacer esto, podemos crear un tipo, y vamos a tener
nuestro nombre de tipo aquí. A éste podemos
llamar, por ejemplo, el día de la semana. Entonces vamos a
decir aquí como un num, que va a
decir como enumerado, abrir y cerrar
paréntesis y luego
tener un punto y coma al final
aquí solo por Ahora podemos poner aquí el orden de los diferentes tipos. Por ejemplo, digamos que primero
tenemos el lunes, después tenemos el martes. Entonces tenemos el miércoles y después continuemos esto en la siguiente línea para que
sea más legible. Entonces vamos a
tener el jueves. Entonces vamos a tener
viernes sábado y domingo. Ahora hemos creado un nuevo
tipo llamado día de la semana, que es un tipo de datos
enumerados, y el orden entre
ellos es como lo vemos aquí Lo que podemos hacer, por ejemplo, es que ahora podemos usar este tipo
para crear otra tabla. Vamos a crear mesa de creación. Entonces aquí podemos
simplemente llamarnos a esta tabla de prueba. De esa manera no tenemos que
preocuparnos por un nombre. En esta tabla, utilicémosla para realizar un seguimiento de por
ejemplo la asistencia. Aunque supongo que un nombre mejor ahora habría sido la asistencia, pero lo que sea.
Dejémoslo así. De lo que podemos hacer un seguimiento
aquí, por ejemplo, es una identificación de estudiante, solo
hagamos que
esto sea un entero. Entonces también vamos a, por
ejemplo, podemos usar
nuestro tipo de datos de enumerador, así podemos llamar a esto
aquí para que sea día de la semana, que va a usar nuestro tipo de datos del
día de la semana, y luego todavía
necesitamos una clave primaria Vamos a llamar a esto alguna clave, y esto va a ser serial, y va a
ser nuestra clave principal. Si ejecutamos esto, aquí mismo,
en realidad nos está dando la opción de qué
declaraciones queremos ejecutar. Por ejemplo, solo ejecutamos
la sentencia create, vamos a obtener
un error porque aún no
hemos creado el tipo
numerado Y esto probablemente se
deba a
que tenemos aquí
el cuadro de creen lo que nos indica que aquí vamos a ejecutar
esta sección de consulta. Ejecutemos esto otra vez
y esta vez, seleccionando toda la declaración. Entonces si hacemos clic en Ejecutar o
seleccionando esto y ejecutándolo, podemos ver ahora que funciona porque ha creado
nuestro tipo para nosotros. Podemos ver aquí si
entramos en nuestra tabla de pruebas, ahora
tenemos un
tipo de datos personalizado o llamado día de la semana, que como podemos ver aquí,
creamos aquí arriba. Lo importante aquí
es también que tenemos el punto y coma al
final aquí porque lo contrario habría intentado
encadenar estos comandos juntos De esta manera, ahora tenemos
diferentes consultas SQL, y es importante simplemente
separar diferentes consultas SQL con punto y coma
para asegurarse de que
no se intenten
encadenar o algo así, sino que sucedan secuencialmente De esa manera, aunque algunas consultas o algunos comandos
puedan ejecutarse en serie, siempre
es una buena práctica
separarlos porque otras veces te vas a encontrar con problemas. Siempre es una buena
práctica simplemente
separar o más bien terminar tus
consultas con punto y coma De esa manera, el editor de consultas sabrá que este es
el final de la consulta. Entonces lo siguiente
que vendrá será el inicio
de una nueva consulta.
14. Insertar valores: Entonces ahora que sabemos cómo
crear y eliminar tablas, así
como también crear nuestros tipos de enumeradores
personalizados y crear tablas con eso Aprendamos cómo podemos
insertar datos en nuestras tablas. Para ello, vamos
a usar insert into. Entonces vamos a tener
aquí el nombre de la tabla. Por ejemplo,
usemos nuestra tabla de prueba, y luego opcionalmente, y volveremos
a esto en un segundo. Podemos poner el orden de las
columnas aquí, pero saltemos esto por ahora. Entonces vamos a usar los valores
de palabras clave. Entonces vamos
a abrir y cerrar paréntesis, y nuevamente, por buenas prácticas,
poniendo el punto y coma al final de la consulta aquí Ahora vamos a
poner en los valores que queremos insertar. Ahora por defecto, los
valores van a estar en el orden en que
también los hemos puesto aquí. Por ejemplo, tenemos una identificación de
estudiante y un día laborable. Debido a que nuestra clave aquí
es en realidad una serie, no
necesitamos
darle un valor. Digamos que nuestra identificación de estudiante
va a ser uno y el valor del día de la semana
va a ser el lunes Entonces podemos ejecutar esto y
luego se va a insertar. Es ejecutar toda la declaración. Se va a
insertar en nuestra tabla de pruebas, los valores uno y lunes.
¿Cómo podemos ver esto? Bueno, podemos simplemente hacer
doble clic en nuestra mesa aquí y eso la va a
abrir en una nueva pestaña. Aquí podemos ver que
tenemos el ID de estudiante uno. Tenemos el día de la semana como lunes, y también tenemos nuestra clave aquí, que fue creada automáticamente para nosotros. Ahora también podemos especificar el orden de las
columnas aquí si queremos. Por ejemplo, tal vez
queremos insertar primero el día de la semana, luego después,
queremos insertar el ID de estudiante Entonces de esa manera, tenemos que
cambiar el orden aquí. Digamos que para el martes, nuevamente
tenemos estudiante uno. Pero esta vez, fíjense que el orden de las
columnas es diferente. Hemos elegido o hemos elegido nuestro pedido personalizado que queremos usar
para
insertar en esta tabla. Pero es importante que
sigamos este pedido personalizado. De lo contrario, la tabla va a suponer que usamos el orden
predeterminado, y así es también como
va a insertar los valores. Una cosa más importante
que también quiero señalar es que aquí
es importante que usemos
comillas simples que no usemos comillas
dobles. Te explicaré por qué en un segundo. Sigamos adelante y ejecutemos esto. Vamos a ejecutar toda
la consulta. Se va a
insertar en nuestra mesa aquí. Déjame cerrarla y reabrirla. Se va a
insertar en nuestra mesa. Nuevamente, tenemos nuestra identificación de
estudiante uno. Tenemos el día de la semana
ahora es martes, que es exactamente lo que
brindamos aquí Ahora bien, la razón por la que
no queremos usar comillas
dobles es porque comillas
dobles se
utilizan para los nombres de las columnas. A veces, podemos tener nombres de
columna que pueden chocar
con otra cosa en SQL. Para especificar que
algo es una columna, también
podemos poner
comillas dobles a su alrededor. Por ejemplo,
usemos aquí el miércoles. Vamos aquí a usar las comillas
dobles para especificar que
estas son columnas. Nuevamente, esto va a
ser para la identificación de estudiante uno. Nuevamente, porque así es como estamos especificando el
orden de las columnas ahora mismo. Si seguimos adelante y ejecutamos eso, y actualmente me está
tirando por error que mi ortografía del
miércoles es incorrecta. Echemos un vistazo a nuestro día
de la semana y tipo de datos, y yo sólo voy a, ya veo. Había un espacio extra aquí. Bueno,
dejémoslo como está por ahora. Solo necesitamos poner un espacio
extra al frente. Aquí, por supuesto,
entonces también se puede ver qué pasa, y esto es en realidad lo
que iba a cubrir a continuación. Pero puedes ver qué pasa
si pones aquí un valor
en un tipo de
datos enumerado que
no pertenece al tipo de
datos en sí Usando ahora el formato
apropiado,
sigamos adelante y corramos
esto una vez más, y luego echemos un
vistazo a nuestra mesa Bien. Echa un
vistazo a una mesa aquí. Si queremos, podemos
cerrarla y reabrirla. Otra cosa que
podemos hacer es que podemos simplemente presionar el botón de refrescar aquí y eso va a refrescar nuestra
tabla como podemos ver aquí, podemos ver que cuando
volvamos a nuestra consola, usando las
comillas dobles aquí. Nuevamente, vamos a especificar la columna. Mientras que usando una sola
comilla, vamos a especificar el valor
que queremos insertar. Si ponemos aquí
comillas dobles, por ejemplo, usemos aquí el jueves, pero en este caso, vamos a usar comillas
dobles. Ya podemos ver por la
codificación de colores que va a fallar. Y vamos a cerrar esto. Pero vamos a probarlo de todos modos. Vamos a seguir adelante y correr esto y correr para que podamos ver
que dice aquí, la columna jueves
no existe. Nuevamente,
las comillas dobles son cuatro columnas. Las comillas simples
son para cadenas de texto. Si seguimos adelante y ejecutamos esto ahora, insertándolo aquí y
simplemente recargando nuestra página, podemos ver aquí ahora otra vez, hemos insertado nuestros datos aquí Qué pasa si
queremos actualizar nuestro tipo que estamos usando ya que ahora hemos estropeado un poco
nuestro tipo Ahora lo que podemos hacer
para esto es simplemente echar un vistazo a nuestros
tipos nuevamente aquí. La sintaxis que vamos
a usar, vamos a decir, alterar el tipo, y vamos
a alterar nuestro día de la semana. Vamos a decir renombrar valor, y vamos a renombrar
el miércoles dos, Sam colon aquí. Corre echemos un
vistazo a nuestro tipo y de hecho sigamos
adelante y lo refresquemos. Así que podemos ver aquí ahora nuestro
tipo ha sido actualizado. Me doy cuenta del mismo
error aquí el domingo. Sigamos adelante y hagamos
eso también para el domingo. Domingo y vamos a
cambiarle el nombre a domingo. Sigamos adelante y ejecutemos esto. Vuelve a nuestros tipos aquí, recargando, y vemos aquí un domingo
ahora también se ha arreglado Si echamos un vistazo a
nuestra actualización de base de datos, podemos ver
que nuestro valor de base también se
ha actualizado
adecuadamente. Ahora hemos visto cómo podemos
insertar datos en nuestra base de datos. También, cómo podemos alterar
el tipo si queremos. Por supuesto, otra opción es si recién estás empezando de nuevo, si tienes una base de datos completamente
limpia, también
puedes simplemente
quitar la tabla y simplemente crear el tipo desde cero y luego continuar con
el tipo correcto. Por supuesto, hay
diferentes opciones para resolver el mismo problema.
15. Cómo ejecutar un script: Ahora, como puedes
ver,
insertar datos en nuestras tablas puede ser
un poco tedioso, sobre todo porque en SQL, tenemos que insertarlos
un valor a Por lo general, es por eso que los datos en las tablas
SQL se insertan
desde la parte posterior dentro donde se configuran las cosas con otras canalizaciones y cada vez que los datos necesarios llegan a
él o pasan a través de
ellos, luego
se cargan en la base de datos. Estar usando el insert
into statements no es particularmente eficiente si usted como usuario tiene que hacerlo porque tiene que
escribirlo todo. Es mucho más eficiente
hacerlo como parte
del código donde eso es parte de del código donde eso es parte sus canalizaciones
de datos
para que
luego pueda simplemente cargar
los datos en la base de datos. Entonces, la mayor parte del tiempo,
en realidad no vas a
estar insertando datos. Si lo estás usando para realizar consultas
para explorar tus datos, analizarlos o
bien para exportarlos
para ejecutar tu propio análisis personalizado, o hacer otras cosas con ellos Estar al tanto de eso. Ahora hay algunas formas en las que podemos
insertar datos más rápido. Por ejemplo, si vamos a nuestro
evento info, y digamos, insertamos en la información del evento, y queremos insertar los valores y solo dar una idea de uno
y un nombre, por ejemplo, login, entonces si podemos ejecutar esto o si queremos
realmente poner en múltiples
valores a la vez, por ejemplo, dos aquí
va a ser click. Entonces como puedes ver
los valores de inserción, podemos simplemente separar
por comas y luego cada fila o
cada registro que
queremos insertar aquí está
dentro de sus propios paréntesis Podemos, por ejemplo,
insertar dos valores. Echemos un vistazo a
nuestra tabla de información de eventos. Actualmente, está vacío. Si ejecutamos esto y luego echamos
un vistazo y para refrescar nuestra tabla, podemos ver que hemos insertado
dos valores a la vez. Pero incluso esto no es
particularmente eficiente. Nuevamente, la mayor parte del tiempo
básicamente todo el tiempo, esto se va a
hacer desde el
lado de atrás a medida que sus datos pasan por las canalizaciones de
datos porque todo esto se
puede automatizar, y eso es extremadamente
bueno porque entonces su base de datos sigue
llenándose datos a medida que sus canalizaciones de datos están procesando los datos
o moviéndola. Ahora, para nosotros, lo que vamos
a hacer es que vamos a usar una base de datos abierta con la que
podamos jugar. Antes de hacer eso,
sigamos adelante y bajemos todas nuestras mesas. Vamos a decir drop sigamos con la sintaxis de
mayúsculas aquí. Vamos a dejar caer
la tabla de información del evento. Sigamos adelante y ejecutemos esto. En este caso, porque
hemos vinculado nuestro
registro de eventos a la información del evento
con una clave externa. Si recuerdas cómo creamos el registro de eventos,
tenemos un enlace aquí. A la información del evento
con la clave foránea. También vamos a usar la sentencia en
cascada para hacer esta serie continua
de eliminaciones donde
están todas estas referencias. Ejecutando esto. Va a eliminar nuestra tabla de información de
eventos para nosotros. Entonces podemos hacer lo mismo
por la info del usuario, nuevamente, cascada el evento porque lo
tenemos aún vinculado
en el registro de eventos, y luego podemos
eliminar el registro de eventos Aquí ya no necesitamos hacer
cascada de nada porque ya
no está vinculado a nada. Sigamos adelante y quitemos eso. Y luego también podemos
quitar la mesa de prueba. Sigamos adelante y quitemos eso. Entonces también podemos cerrar nuestro toque extra aquí
porque ya no es relevante. Vamos a
volver al agarre de datos, y vamos a borrar
nuestro editor de consultas aquí a nuestra consola de consultas. Para obtener nuestros nuevos datos, vamos a ir
a esta página de getup aquí para la base de datos chinook Incluye un enlace a esto
en la pestaña de materiales, para que también puedas
referenciarlo desde allí. Para obtener estos datos,
esta va a ser una consulta SQL que podamos ejecutar, solo
puedes presionar descargar aquí, y o se va
a descargar gratis directamente o como lo hizo para mí, va a abrir en un
segundo, si le hice clic Lo va a abrir
aquí en una nueva pestaña y
se puede ver aquí todo esto es
en realidad sentencias SQL. Nuevamente, si tienes SQL o si tienes tabla SQL está
integrada en tu empresa. La mayoría de las veces,
todavía no se
va a insertar
usando sentencias SQL, sino que se va
a conectar directamente a la tabla SQL. Pero de todos modos. Aquí, todo
esto se va a hacer por nosotros a través del
uso de consultas SQL. Si quieres,
también puedes echarle un
vistazo a esto para ver qué
está haciendo en realidad. Pero si quieres
entonces usar esta consulta, vas a hacer click
derecho aquí. Bien. Vas
a hacer clic derecho, y luego puedes hacer clic en guarda. Entonces lo he guardado
en el escritorio, como ya pueden ver. Solo asegúrate de quitarte la extensión
dot TXT para que podamos
usarla en un segundo. Y luego solo presiona Guardar. Puedes, por
supuesto, también
guardarla donde quieras. Ya lo he hecho.
Para ejecutar esta consulta SQL o la serie de
consultas SQL que
ahora hemos descargado y
agregarlas a nuestra base de datos. Vamos a hacer
click derecho sobre nuestro esquema aquí. Entonces vamos a tener
aquí ejecutar script SQL. Vamos a elegir
este script SQL aquí. Vamos a abrir el golpe, y luego lo va
a correr por nosotros. Sólo podemos esperar
hasta que esté terminado, que sólo tardaría
un par de segundos. Podemos ver aquí ahora
que ya está hecho,
se han creado nuevas tablas para nosotros. Podemos echar un vistazo a cada uno si
queremos y simplemente
explorarlos un poco, o puedes
verlos directamente aquí también. Ahora tenemos datos que
podemos usar que
en realidad son mucho más de lo que podríamos habernos insertado manualmente. Si desea abrir
el editor de consultas en porque se dio a conocer
de accidente. Nuevamente, sabemos cómo hacer eso. Así es como entonces
también podemos ejecutar scripts SQL, si queremos, que en este caso, solo nos permite crear una
práctica o nos permite usar una base de datos de práctica
que luego podemos usar para consultas adicionales De nuevo, por supuesto, si
vas a estar trabajando con una
base de datos de una empresa o algo así, la base de datos ya
va a ser llenada, y así cuando lo
estés haciendo queering, solo vas a enfocarte en
hacer tu análisis o encontrar los datos
necesarios que puedas sacar para hacer
más cosas con Dado que la carga
va a
ocurrir principalmente en las canalizaciones de datos porque va a ser
mucho más eficiente actualizar todo eso automáticamente como parte
de los pipelines
16. Datos de lectura: Todo bien. Entonces, ahora que tenemos nuestras tablas disponibles para nosotros, aprendamos ahora cómo podemos obtener datos
de nuestras tablas. Sigamos adelante y solo echemos
un vistazo a la primera mesa aquí, la de discos llamada álbum. Si solo echamos un vistazo aquí, vemos que tenemos varias columnas
diferentes, varios atributos diferentes,
tenemos el ID del álbum. Tenemos el título,
así como también una identificación de artista. Tenemos diferentes discos aquí que están hechos por
diferentes artistas, y cada disco, por supuesto, también tiene su propio ID único. ¿Cómo podemos obtener datos de aquí? Cómo podemos leer los datos de esta tabla
usando una consulta SQL. Vamos a
volver a nuestra consola,
asegurándonos de que
estamos conectados a nuestra fuente de datos correcta aquí
usando esa consola correcta. Ahora para obtener datos de nuestra tabla, vamos a decir, seleccione. Entonces vamos a decir estrella, lo
que significa todo. Selecciona todas las columnas. Después queremos seleccionar
del disco. Ahora bien, si
le doy Enter aquí
y dejo que se complete auto, en realidad van a ver
que tenemos comillas por aquí. Hablaremos de
estos y también
hablaremos de esta estrella aquí, así
como de cómo podemos
modificar estas cosas. Pero antes que nada, vamos a ejecutar esto y ver los
resultados que obtenemos. Si ejecutamos esto, podemos ver aquí, estos son los resultados que
obtenemos de nuestra consulta. Podemos ver que hemos seleccionado
tres columnas diferentes. Tenemos el
ID del álbum, el título, así
como el
ID del artista, y podemos ver aquí, podemos desplazarnos hacia abajo y seleccionar un montón de
datos o en este caso, realidad todos nuestros datos
de nuestra tabla de álbumes aquí. Primero echemos un vistazo a estas comillas porque muchas veces en las consultas SQL,
en realidad no vas a tener comillas
alrededor de los nombres de tus tablas. ¿De dónde
viene esto? Bueno, si nos fijamos en el
script SQL que
ejecutamos, en realidad podemos ver aquí la
sentencia create table que usaron, poner comillas
alrededor del nombre de la tabla, lo que significa que ahora tenemos que referirnos a ella usando comillas. Si me quité las
comillas, ya se
puede ver
aquí se pone roja, pero podemos intentar ejecutarlo de todos modos. Vamos a obtener
un error porque dice que la tabla no existe. Cómo podemos cambiar esto porque no es muy agradable tener siempre que
poner comillas alrededor de él. Para actualizar esto,
nuevamente vamos a usar la sentencia alter table, y vamos a
alterar el disco, nuevamente, poniéndolo entre comillas aquí, y luego
vamos a decir, renombrar dos, y ahora sólo
vamos a llamarlo álbum
sin las comillas. Sigamos adelante y ejecutemos esto. Ahora, sigamos adelante y escribamos
la misma declaración de selección, seleccione estrella del álbum. Pero esta vez, no
vamos a poner
comillas por aquí. Si ejecutamos esto,
puedes ver que esta vez no
tenemos ningún problema porque ahora
hemos renombrado
nuestra tabla para pasar de las comillas a un nombre de tabla sin
comillas, lo cual es simplemente mucho
más conveniente porque no tenemos que
poner siempre comillas
alrededor de todo En algunos casos, puede
encontrar esto y eso es solo porque la instrucción create
table, como podemos ver aquí, tenía comillas en la cosa
original create table. Hablemos también de
esta estrella aquí. Lo que ponemos aquí son
las columnas que
queremos seleccionar de nuestra tabla. En este caso, ponemos estrella, significa seleccionar
cada columna. A veces no queremos
seleccionar cada columna. Y si a veces solo
queremos seleccionar un subconjunto de columnas. Digamos que solo nos importa
el ID del disco y el título. No queremos
extraer al artista. Bueno, lo que podemos hacer es decir que vamos a
seleccionar el ID del disco, y también vamos
a seleccionar el título. Del disco. Ahora otra vez, verás aquí necesito poner
comillas alrededor,
y nuevamente, el auto
fill aquí de Data Grip lo ha hecho por mí. Nuevamente, eso es solo porque si
entramos aquí en nuestra consulta SQL, entonces podemos ver que
los nombres de las tablas también
fueron creados
usando comillas. Si volvemos,
podemos volver a ver aquí, necesitamos usar comillas
alrededor o nombres de mesa también. Si ejecutamos esto,
podemos ver aquí ahora nuestros resultados actualizados ya no
contienen el ID de artista, que tenemos aquí. Pero en cambio, tenemos el
ID del disco así como el título. Ahora también podemos, por supuesto, cambiar el orden aquí. En lugar de tener primero
el ID del álbum, tal vez
podamos
leer el título, y luego el ID del álbum,
así que si ejecutamos esto, entonces podemos ver
aquí la salida
del orden de nuestras columnas
también va a ser volteada Después de la declaración select aquí, seleccionamos qué columnas queremos. Si queremos seleccionar todas las
columnas, ponemos una estrella. Si queremos seleccionar columnas
específicas, tenemos que poner su nombre aquí. Crear instrucción de tabla
no utiliza comillas en la
definición de los nombres de las columnas, entonces tampoco
tenemos que usarlos aquí. Pero en este caso, lo hacen, lo que significa que también tenemos que
utilizarlos dentro de nuestro código. Ahora, a veces cuando
solo estás explorando una base de datos o tal vez estás escribiendo
una consulta y quieres ver los
resultados de la consulta, pero no quieres que
todo te devuelva
porque devolver todos los datos, especialmente, así que hay muchos datos en tu base de datos
es mucho trabajo. Hay una declaración extra
que podemos poner
al final de nuestra consulta llamada mit. Esto limita el número de filas que se nos devuelven y
que realmente van a aparecer. Por ejemplo, si pongo mit cinco, esto significa que aquí sólo vamos
a ver cinco filas. Van a ser las
primeras cinco filas. Si ejecutamos esto,
podemos ver aquí ahora
solo tenemos las primeras cinco
filas devueltas a nosotros. Si hago límite dos, sólo
va a mostrar las dos
primeras filas. Si lo hago 50, nos
va a dar
las primeras 50 filas. De esa manera, también puedes administrar cuántos
valores se devuelven, cuales puedes usar
dentro de las consultas si quieres para no sé si estás haciendo algún filtrado personalizado específico, o también puedes usarlo
cuando estés probando tus consultas y no
quieres que se devuelvan todos los valores, pero solo quieres asegurarte de
que esté funcionando correctamente, y entonces solo quieres
par de valores, quieres limitar
tus resultados a un par de filas para que
puedas echarles un vistazo, asegurarte de que funcione
correctamente o tal vez detectar algunos errores,
arreglar tu consulta, intentarlo de nuevo, y luego
hasta que esté funcionando, y luego también puedes volver eliminar la sentencia limit, a
eliminar la sentencia limit,
si quieres
ejecutarla en el
conjunto completo de datos o mejor dicho si quieres que se devuelvan
todos los registros.
17. Crear cuadros a partir de el resultado de las consultas: Entonces, en la lección anterior, aprendimos sobre cómo podemos leer datos de nuestras tablas
dentro de nuestra base de datos. Pero ahora echemos un vistazo a
cómo realmente podemos crear nuevas tablas a partir de los resultados porque a veces tal vez
estás escribiendo una consulta, y luego quieres
guardar esos resultados en una tabla separada para que
puedas acceder rápidamente a ella para su visualización
porque has hecho algún procesamiento de datos o
tal vez usarlo en otro lugar. Y así puede haber, por supuesto, situaciones en las que desee almacenar los resultados
de su consulta en solo una tabla separada para uso
posterior en la
línea. ¿Cómo podemos hacer eso? Para ello, vamos
a poner primero aquí, crear tabla, y luego vamos a
tener el nombre de la tabla. Oh. Crear tabla, y
vamos a tener el nombre de la tabla. A lo mejor llamamos resultados a este
álbum, y luego vamos a decir como, y luego vamos
a poner paréntesis alrededor de nuestra
declaración selecta así Lo que eso significa es que
vamos a crear una tabla y vamos a
usar los resultados de aquí. Ahora notarás que
en realidad no estamos definiendo ninguna de las columnas o tampoco estamos definiendo ninguno de
sus tipos de datos. Todo eso se va
a inferir de los resultados
de nuestra consulta aquí Si corremos esto, entonces sólo manteniendo un ojo en
el lado izquierdo aquí. Podemos ver ahora tenemos
nuestra tabla de resultados de disco, que es como podemos ver, solo los resultados de nuestra consulta aquí y
va a ser idéntica a nuestra tabla de discos porque esto es nuevamente lo que
hemos regresado de aquí. También podemos echar un vistazo al
interior si queremos. Podemos simplemente
echar un vistazo por dentro de aquí, podemos ver que se infieren los
tipos Una cosa que sí notamos es que aquí no hay una
clave primaria definida. La clave primaria, así como posibles quilla foráneas
no se continúan en
nuestra nueva mesa aquí Pero aún podemos
usar los resultados de nuestras consultas y luego
guardarlas en tablas
separadas que luego
podamos usar esos resultados para lo que sea
específicamente que nos gustaría. Ahora, como ya me has visto
hacer varias veces ahora, he empezado a expandir
nuestras consultas sobre varias líneas solo para
que sea más fácil de leer. A veces está totalmente bien
ejecutar toda esta consulta como una sola, pero en otras ocasiones
esto puede no funcionar o puede que no sea óptimo porque
se volverá realmente muy larga. Por supuesto, puedes
dividir tu consulta en
varias líneas, lo que también hará que
sea más fácil de leer. Por lo general, quieres
dividirlo en puntos clave específicos. Por ejemplo, si estás seleccionando
de diferentes columnas, normalmente lo que quieres hacer
es que también quieras tener la declaración from
en una nueva línea, y podemos hacer algunos pedidos
adecuados aquí. Queremos crear una tabla y
tener el nombre de la tabla aquí, y luego podemos poner
nuestra consulta aquí. Si desea
seleccionar, por ejemplo, columnas
específicas
como el ID del álbum. Entonces en la siguiente línea aquí, podemos tener por ejemplo, el título para que de
esta manera se vuelva mucho más legible y no se extienda mucho
en la horizontal. ¿Qué pasa si
volvemos a ejecutar esta consulta ? Ejecutando todo el asunto. Esta vez
vamos de nuevo error porque nuestra tabla
ya existe. Lo que podemos hacer es que podemos modificar nuestra sentencia create
table aquí, y podemos decir, crear
tabla si no existe. Ahora bien, esto funciona para la instrucción create table que usa el resultado de
la instrucción select, pero esto también funciona para nuestra instrucción
general create table. Recuerda cuando teníamos
nuestra tabla de creación y luego proporcionamos
el nombre de la tabla, y definimos cada columna así
como cada
tipo y así como claves
primarias y referencias de clave
externa así
como tal vez
otras restricciones. También ahí podemos usar
crear tabla si no existe. Lo bueno de esto
es que esto solo ejecutará la sentencia o
solo intentará crear la tabla si
no existe ya. Entonces no va
a tener este problema de chocar con una mesa
ya existente Ahora, una cosa más por la
que también quiero
pasar es cómo podemos
acceder a los nombres de las tablas. Vamos a quitar esto de nuevo, y sólo vamos
a seleccionar todo. Ahora actualmente estamos haciendo
aro Volvamos aquí. Actualmente estamos haciendo seleccionar
todo del álbum, y es inferir
qué tabla
queremos porque ya estamos en la base de datos
así como en el esquema Pero a veces podemos tener o varias bases de datos
o varios esquemas ¿Cómo podemos hacer
referencia específicamente a la tabla exacta que queramos si tenemos varias bases de datos aquí
o varios esquemas También podemos proporcionar
la ruta completa a nuestra base de datos o
más bien a nuestra tabla. Podemos decir, queremos ir de RDB aquí queremos
elegir el esquema público Y aquí queremos
elegir el disco. Si hacemos clic en Ejecutar en esto ahora, puedes ver que
sigue funcionando completamente. Pero en este caso,
estamos haciendo referencia al camino completo a nuestra mesa Ahora esto es, por supuesto, útil. Nuevamente, si tenemos varios esquemas
diferentes o varias
bases de datos diferentes contenidas dentro, entonces siempre podemos
asegurarnos si los nombres de las tablas son repetitivos que estamos
haciendo referencia a las También puedo hacer lo mismo. Por ejemplo, eliminemos nuestra tabla de resultados de álbum
que hemos creado. Vamos a decir drop table, y vamos
a soltar la tabla de
resultados del álbum usando la ruta de referencia
completa. También podríamos usarlo solo
con este componente aquí, pero también podemos usar la ruta de referencia
completa. Si ejecutamos esto, y
podemos ver nuestra tabla
ahora se quita, y también podemos ver que nuestro agarre de
datos la actualiza y básicamente dice, esto no
está definido. Se trata de una referencia desconocida. Podemos ver que podemos usar tanto rutas absolutas
como una ruta relativa, mucho de esto es solo
facilidad de implementación. En nuestro caso, por ejemplo, cuando
tenemos solo una base de datos, un esquema con un
montón de tablas en
ella, va a ser mucho
más fácil simplemente hacer referencia a la tabla directamente en
lugar de poner la ruta completa. Pero a medida que tu base de datos crece
o obtienes más esquemas o tal vez la compañía ya tiene varias bases de datos diferentes
o varios esquemas diferentes Usar estos
path absolutos puede ser genial porque se
asegura de que estés haciendo referencia a las tablas correctas
18. 16Aliasingy 16AliasingAndOrderingHB: En ocasiones cuando ejecutamos consultas o cuando estamos tratando de sacar columnas
específicas están haciendo referencia a tablas específicas. Los nombres pueden llegar a ser muy largos. Entonces una cosa que quiero ver ahora es usar alias para nombres para que podamos acortar los nombres que estamos usando en nuestras consultas. Entonces echemos un vistazo a la mesa de empleados. Ya lo abrí aquí. Podemos desplazarse por las diferentes columnas disponibles para nosotros. Y sólo saquemos tres columnas aquí. Saquemos el FirstName, el LastName, y también saquemos su correo electrónico. Entonces vamos a decir seleccionar nombre y luego vamos a seleccionar apellido. Y también vamos a seleccionar el correo electrónico de la tabla de empleados. Tengo razón. Y así vamos a poner aquí nuestro punto y coma. Y limitemos de nuevo nuestros resultados. Pero también pongamos algo de estructura aquí. Por lo que r de declaración va a estar en una nueva línea. Nuestro límite va a estar en una nueva línea, y cada una de nuestras columnas también va a estar en una nueva línea. Entonces esto simplemente lo hará más legible como la consulta, tal vez sea más grande. Y también, por supuesto, pongamos un número aquí cuando estemos limitando nuestra declaración. Entonces si ejecutamos esto, podemos ver aquí estos son nuestros resultados. Y notarás que en este caso aún tenemos que poner las comillas alrededor del nombre de la tabla porque aquí no he actualizado el nombre de la tabla. Y nuestra columna sigue requiriendo comillas. Ahora cuando nuestras columnas se crean sin comillas, todavía
podemos usarlas para no conocer nombres de columna, pero no es necesario. En este caso. En realidad es necesario para nosotros porque fue creado con las comillas. Y así si recordamos, si los
quitamos, nos vamos a topar con un tema porque nuestra tabla fue creada con comillas alrededor. No obstante, el uso de comillas alrededor los nombres de las
columnas es en realidad bastante agradable porque es mucho más fácil ver lo que la columna o cuáles se llaman nombres y cuáles son otras cosas. Por lo tanto, mantener comillas alrededor de los nombres de las columnas en realidad no es tan malo, pero sí, y también son nombres de tabla de Kieran, pero sí se pone un poco tedioso para el usuario en dos amonios. Entonces si quieres hacer eso, puedes por supuesto, como vimos en las lecciones anteriores, solo alterar el nombre de la tabla aquí y entonces ya no tienes que usar las comillas alrededor. Muy bien, Entonces, ¿cómo podemos agregar algunos alias a o columnas? Por ejemplo, digamos que queremos que nuestra columna de salida no se llame FirstName, sino que queríamos darle otra cosa. Por ejemplo, digamos que solo queremos usar la columna de salida aquí para ser primero. Y queremos que nuestro apellido aquí se llame último. Y queremos que el correo electrónico se quede como correo electrónico para que no los cambiemos. Entonces si ejecutamos esto, podemos ver aquí ahora nuestra salida es primera y última, y nuestro correo electrónico se ha mantenido igual. Entonces podemos ver aquí podemos asignar alias a nuestros nombres de columna, y eso en realidad los va a cambiar en las respuestas resultantes que obtuvimos. Y más adelante a medida que las consultas se hacen más grandes, entonces también
podemos hacer referencia o nombres de tabla usando los alias que les asignamos aquí, en lugar de usar el nombre completo. Pero no es sólo para columnas que podemos asignar alias, también
podemos hacerlo para tablas. Por lo que para asignar un alias para una tabla, solo pondremos un espacio aquí. Y entonces simplemente pondríamos el alias que queremos usar. Por ejemplo, si queremos taquigrafía para empleado, que puede ser uso MP. Y eso significa que ahora también podemos usar MP para referir empleado. Entonces un lugar donde se puede hacer eso es, por ejemplo, a veces cuando se trata de múltiples tablas en la misma consulta, y tal vez algunas de las columnas son las mismas columnas a través de varias tablas diferentes. Desea asegurarse de que está haciendo referencia a la columna correcta de la tabla correcta. Entonces al igual que vimos cuando estábamos seleccionando de una mesa y dimos el camino completo a la mesa. Podemos hacer lo mismo por las columnas. Entonces, por ejemplo, podemos entonces hacer referencia a nuestra tabla
y aquí, y podemos decir m dot nombre. Se puede decir m dot apellido. Y podemos decir m dot email. Y así si ejecutamos esto, vemos que se ejecuta esto. Entonces vemos que nuestros resultados no van a cambiar. Pero la forma en que estamos escribiendo nuestra consulta lo hace porque ahora estamos haciendo referencia a las cosas de manera diferente. Entonces podemos ver aquí, así es como damos alias a nuestros nombres de columna usando el como palabra clave. Pero si queremos darle un alias a un nombre de tabla, solo
podemos poner un espacio después de tener la declaración frontal aquí en el nombre de la tabla. Y luego ponemos el alias que queremos darle al nombre de la tabla. Y esto solo nos permite usar este alias a lo largo nuestra consulta para que estemos haciendo referencia esta tabla en lugar de tener que escribir el nombre completo de la tabla. Por supuesto, en este caso puede parecer un poco innecesario sólo porque ya podemos extraer las columnas así. Pero cuando tienes varias tablas diferentes en la misma consulta, puede ser realmente agradable. Para asegurarse de que cuando hay columnas diferentes,
son columnas idénticas a través las diferentes tablas que hace referencia a la columna derecha de la tabla correcta. Y así también es entonces cómo podemos usar la taquigrafía de la tabla que estamos usando. Y podemos usarlo, por ejemplo, para acceder
a los atributos de columna dentro para asegurarnos de que estamos accediendo a la columna desde esta tabla específica, que es una taquigrafía para esta tabla aquí. Ahora otra cosa que también quiero repasar es ordenar resultados. Entonces en este momento, la forma en que se están devolviendo nuestros resultados es justo por cierto que se insertan aquí. Para que veamos que aquí tenemos el orden. Y así también es exactamente como nos van a devolver aquí. Pero a veces realmente queremos ordenar las cosas, ya sea ordenar como parte de la consulta y luego hacer otra cosa más adelante, o simplemente tener los resultados finales ordenados. Entonces para hacer eso, vamos a usar el comunicado orden BY con 1D aquí. De acuerdo, así que el orden POR ahora podemos poner en los nombres de las columnas o la ubicación de las columnas. Miraremos ambos y luego podremos ordenar por esos. Entonces digamos que primero queremos pedir por el Nombre y luego por el apellido. Y luego queremos devolver nuestros resultados. Y queremos ordenar en orden ascendente para que lo que
sea más bajo sea primero y luego vayamos en orden creciente. Entonces para ordenar primero por el FirstName, entonces
podemos poner aquí primero, lo cual va a hacer referencia, en este caso, al alias de columna que usamos aquí arriba. Entonces vamos a ordenar por fin. Y ahora también queremos decir que ambos deben ordenarse en orden ascendente, que en realidad va a ser el predeterminado. Pero vamos a ejecutarlo así primero. Y luego pondremos específicamente el orden ascendente. Entonces estamos ejecutando esta consulta. Y podemos ver ahora estamos ordenando en una orden ascendente de nombre primero, y luego en caso de que haya un primer nombre de tiempo, que en este caso no parece que haya para ellos y use el apellido para ordenar. Entonces para comprobar esto, también
podemos entrar a nuestra mesa, que en realidad es bastante pequeña como se puede ver. Y también podemos simplemente hacer clic en el pedido por nombre aquí. Y ya veremos que vamos a conseguir el mismo pedido que lleguemos aquí. Entonces de nuevo, el enunciado orden BY es el orden por el que queremos ordenar las columnas. Entonces primero vamos a ordenar por la primera columna aquí, que es nuestro alias para la columna FirstName. En caso de que haya empate, entonces
vamos a usar esta última columna, que es nuestro alias para la columna de apellido. En este caso, no tenemos lazos, por lo que realmente no hace nada. Y luego después de eso no hay un orden específico que estemos usando. Entonces va a por si hay más lazos, solo por defecto volver a la frontera, el orden natural de los datos dentro de nuestra tabla. Ahora, para especificar explícitamente que queremos usar orden ascendente, podemos poner ASC aquí, y podemos poner ASC aquí. Para que podamos volver a ejecutar esto. Ahora nuestros resultados no van a cambiar porque también por defecto es ASC. Pero se puede ver después de cada columna que tenemos en este orden BY cláusula aquí, también
podemos especificar el orden que queremos hacer, ya sea ascendente o descendente. Entonces si queremos ordenar primero el FirstName en orden descendente, y luego en caso de lazos, utilice el apellido en orden ascendente. Podemos especificar descendente así, y luego podemos dejar el LastName como ascendente así. Entonces si ejecutamos esto, ahora nuestros resultados van a cambiar porque estamos usando primero el FirstName, y estamos ordenando en orden descendente, lo que significa la más alta primero para urnas grandes alfabéticas más cercanas a zed. Y luego en caso de empates, en cuyo caso actualmente no hay ninguno, vamos a usar el apellido. Entonces en este caso otra vez, no se está utilizando el apellido, pero el orden va a ir primero por orden de nombre,
descendente, por lo más alto primero y luego Lois en el mismo fondo. Y en caso de empates, usa el apellido y luego ordena esas columnas que tienen lazos en el FirstName, apellido, pero aquí usa un orden ascendente. Y así como puedes ver, podemos especificar el orden específico que queremos
utilizar para cada columna que queremos pedir POR. Y entonces también podemos ordenar por, por ejemplo, y la columna de correo electrónico aquí. Si queremos. También podemos realmente ordenar BY columnas
de las que no estamos seleccionando siempre y cuando estén en la tabla original en este extracto de. Entonces, aunque no los seleccionemos para su visualización, en realidad todavía
podemos ordenar por ellos porque están en la tabla original. Entonces podemos ordenar aquí, por ejemplo, tomemos la fecha de nacimiento. Por lo que podemos ordenar por nombre de nacimiento y va a por defecto a orden ascendente. Para que podamos ejecutar esto. Bueno, podemos ver que en realidad no tenemos el nacimiento en columnas, lo que realmente no podemos verificar que este MOOC siga en orden por la fecha de nacimiento, aunque no lo estemos usando en nuestra declaración selecta final aquí. Por último, otra cosa de sintaxis que podemos usar es en lugar de poner los nombres de las columnas o alias. Entonces por ejemplo, aquí tenemos el nombre de la columna y previamente reutilizado el alias de columna. En primer lugar. Podríamos tener igual de bien usar el nombre de pila, nombre columna
verdadero aquí. Se puede ver que ambos funcionarían, pero también podemos usar primero como lo hicimos poniendo esto en orden descendente ahora, y luego usando el último. Y pongamos también esto, o mantengamos esto en orden ascendente. Entonces aquí estamos usando los alias. Podemos usar los nombres. Y vamos a correr esto otra vez para mostrar. Pero algo más que también podemos hacer es que podemos usar el número para la columna en la que aparece en nuestra declaración selecta. Entonces digamos que queremos ordenar primero por el primero aquí, y luego segundo pi o apellido. En realidad también podemos usar el uno, lo que significa que primero vamos a indexar por la primera columna de nuestra declaración selecta. Y luego dos significa la segunda columna en nuestra declaración selecta. Entonces esto es otra vez sólo otra taquigrafía que podemos hacer en caso de que le llame nombres, me haga demasiado tiempo. Podemos escribir nuestro código más ordenado, más limpio y más rápido. Entonces puedes ejecutar esto y podemos ver que vamos a obtener los mismos resultados porque no cambia. Podemos tener uno aquí el cual se hace referencia, yendo a hacer referencia a la primera columna que estamos seleccionando aquí. Podemos poner el alias aquí, que es el alias que hemos asignado a esta columna. Para que podamos ejecutar esto y ver. O también podemos poner el nombre completo de la columna. Todos estos son equivalentes. Por supuesto, usar el alias, en mi opinión, es algo más fácil porque por eso estamos asignando alias. B, por supuesto, también puede utilizar el nombre completo de la columna o la versión numérica de la misma, dependiendo de su preferencia. Los números creo que son una buena taquigrafía, pero a veces pueden ser confusos porque entonces hay que volver a mirar hacia arriba y hay que ver cuál es la primera columna y cuál es la segunda columna. Y en caso de que estés seleccionando algo así como 10 columnas, en realidad
tienes que empezar a contar atrás para asegurarte de que estás usando están haciendo referencia a la columna correcta. Por lo que eso puede ser bueno para la taquigrafía. Pero claro, ya sabes, todos tienen sus compensaciones. Personalmente, prefiero el alias más, pero realmente depende de ti lo que te permita hacer las consultas más legibles. Ahora como también podemos ver aquí por el pedido, podemos encadenar en sesgo de orden adicional. Entonces por ejemplo, podemos decir, vale, queremos ordenar primero por la primera,
la primera columna aquí, luego por la segunda columna aquí, ya que alguna vez queríamos sus 2s. Y luego queremos pedir, por ejemplo, por la fecha de nacimiento, que ni siquiera está incluida en nuestras selectas columnas aquí. Y entonces podemos poner esto aquí. Y digamos aquí queremos ordenar descendente. Y luego queremos tal vez pedir por el correo electrónico. Entonces podemos poner un tres aquí si queremos. O podemos poner correo electrónico lo que queramos. Entonces podemos ver, y tal vez queremos poner esto ascendente para que podamos ver, podemos encadenar diferentes ordenamientos juntos, solo separando todo por coma. Y luego el orden que va a elegir como primero va a ser este desempate, va a usar esto y en TI para ambos, va a usar este desempate para los tres de estos, va a usar esto y así sucesivamente. Y así se puede ver para cada columna, también
podemos especificar si queremos hacer orden descendente o ascendente.
19. Comparación de filtering condicional: Ahora, acabamos de ver cómo podemos leer los datos
de nuestra base de datos. Pero claro, leer
la base de datos completa
o cortarla después de cierto
número o límite de filas no es realmente lo ideal. Lo ideal es
hacer más con SQL que solo leer todos los
datos de nuestra base de datos. Lo primero que
vamos a aprender a hacer extra va a ser filtrar. Echemos un vistazo a
esta pista. Mesa aquí. Si nos desplazamos por
él, podemos ver
que tenemos diferentes columnas aquí, tenemos el
ID de pista, el nombre de la pista, el ID del álbum, el ID de tipo de medio, ID de
género, los compositores, el tiempo y milisegundos
de la canción, el tamaño de byte de la canción, así
como el precio de
las canciones individuales Intentemos tomar esta
mesa e intentemos
encontrar todas las canciones
compuestas por ACDC Para ello, vamos a decir,
seleccionar, y vamos
a decir que acaba de empezar. De la tabla de pista
hit entrar aquí. Nuevamente, tenemos las
comillas. Nuevamente, porque así fue como se creó
la tabla con las comillas
alrededor de ella y luego
solo sigamos adelante y limitemos nuestros
resultados primero a cinco filas por si acaso para que
podamos hacer comprobaciones antes
de devolver toda la tabla. Ahora bien, para filtrar específicamente para algo o para hacer
filtrado en general, vamos a tener aquí una
declaración extra llamada where. Aquí podemos decir, para qué exactamente
queremos filtrar. Por ejemplo, actualmente
queremos filtrar por donde compositor, y queremos encontrar donde el
compositor es igual a ACDC ¿Cómo hacemos esta comparación? Bueno, las cadenas se
van a poner en citas
simples
como las que tenemos aquí o el texto se va a poner
en citas simples Vaya a nuestra base de datos aquí. Nosotros nuevamente, ACDC está escrito todo el capital con una barra
hacia adelante aquí Vamos a decir, Donde
compositor es igual a ACDC. Observe aquí, tenemos
un solo signo igual. En caso de que conozcas algún otro lenguaje de
programación, es costumbre usar signos dobles iguales y otros lenguajes. Pero en SQL aquí, tenemos un solo signo igual. Sigamos adelante y
ejecutemos esta consulta. Podemos ver aquí todos
nuestros resultados de retorno
están compuestos por ACDC Entonces si queremos,
también podemos desactivar este límite aquí y obtener la lista completa de filas o la
lista completa de registros. Podemos ver cada registro aquí cumple con este criterio
ACDC Ahora también podemos hacer otro
tipo de comparaciones. Por ejemplo,
algo más que podamos hacer es menor o igual a. Ahora, por supuesto, no
va a tener mucho
sentido comparar
menos o igual a con un nombre porque entonces estamos
haciendo una clasificación de texto rara, que va a estar
basada principalmente en cosas alfabéticas. Aquí no va a
tener tanto sentido. Usemos una columna diferente. Usa la
columna de milisegundos aquí. Digamos, donde
los milisegundos son menores o iguales a, y escojamos dos 100,000
milisegundos, 200 segundos Estamos seleccionando todas las filas o todas las columnas
más bien de la pista donde los registros cumplen con
este criterio donde la columna de milisegundos es
menor o igual a 200,000 Sigamos adelante y limitemos de nuevo
nuestra respuesta. Entonces vamos a ejecutar esto. Ahora podemos ver si nos
desplazamos hacia la derecha aquí, todas nuestras pistas tienen un tiempo inferior a
200,000 milisegundos, menos de 200 segundos. Nuevamente, podemos quitarle
la declaración de límite. Ejecutar esto al completo en lugar de
obtener todos los valores devueltos, podemos ver todos ellos aquí tienen
tiempos menores de 200,000 milisegundos, menos de 200 segundos. También podemos hacer un
mayor o igual a. Todo lo que es por lo
menos 200 mil. Esto, y obtenemos
todo lo que tiene los milisegundos aquí por encima 200,000 milisegundos
como podemos ver También podemos simplemente quitarnos a
los iguales y simplemente decir mayor que o
también podemos hacer solo menos que y así podemos ver que podemos hacer también
filtros específicos como ese. La principal diferencia, por supuesto, usar menos o
menos que o igual a, es que los
dos iguales también incluyen todo lo que es
igual a 200,000, mientras que el menor que solo
incluiría aquellas instancias que
son menores a 200,000. Por ejemplo, aquí
tendríamos uno, nueve, nueve, 999. Esa sería la instancia
más alta que
podemos incluir asumiendo
que aquí todo es integras porque de lo contrario
estaríamos igual a 200,000 y así eso sería igual
y eso solo estaría incluido en el caso
menor que o igual, o cuando verificamos la igualdad, o cuando verificamos por
mayor o igual
20. 18ConditionalFilteringFiltering, 18ConditionalFilteringGroupComparisonHB: Por lo que acabamos de ver cómo podemos hacer algún filtrado básico buscando la igualdad. Están buscando menor que o mayor que o menor que igual o mayor que o igual a. Pero qué pasa cuando queremos encontrar todos los, por ejemplo aquí en la columna del compositor, todos los discos donde Angus Young, uno de los compositores. Actualmente no podemos hacer eso porque si miramos, por ejemplo, donde compositores iguales a Angus Young, no nos va a dar ese valor porque no es exactamente igual a él. También hay otros componentes para ello. Y así actualmente no podemos usar la igualdad para encontrar todos esos registros porque aquí también hay otros elementos, pero hay otras cosas que podemos hacer. Entonces echemos un vistazo a eso ahora. Entonces, en primer lugar, vamos a escribir de nuevo nuestra declaración selecta, seleccione todas las columnas de la pista. Y limitemos nuestros resultados ahora mismo. Y de nuevo, aquí vamos a tener la declaración donde. Ahora queremos encontrar dónde Compositor, y queremos encontrar dónde está Angus Young en el compositor. Entonces lo que podemos hacer es que podemos usar la palabra clave like. Y así vamos a decir dónde está el compositor. Y entonces tenemos algo de texto aquí, así podemos decir Angus Young. Pero en este caso, seguiríamos buscando coincidencias exactas a esto. Pero hay algunos personajes que podemos poner en que básicamente
dan algo de espacio para especie de expandirse. Entonces si usamos un por ciento, entonces eso significa dónde está este componente aquí. Pero el porcentaje significa que podemos tener cualquier cosa después de este punto. Y el porcentaje al frente también significaría que tenemos algo al frente. Por lo que podemos tener cualquier cantidad múltiple de carácter al frente. Y entonces el porcentaje significa igual de personajes aquí. Pero lo importante es que en algún lugar dentro coincidamos
exactamente con Angus espacio joven, así. Si le quitáramos a la persona de frente, sería la fila tendría que empezar con Angus espacio joven. Y luego después de eso podemos tener cualquier cosa. Y si tuviéramos, por ejemplo, el porcentaje y la frontera, entonces básicamente tendríamos que terminar con Angus espacio joven. Entonces para estar seguros, podemos usarlo así, que significará que puede haber cualquier cosa delante y cualquier cosa detrás. Pero en algún lugar dentro de nuestro registro, necesitaríamos ver exactamente esta pieza de texto aquí. Entonces sigamos adelante y ejecutemos esto. Y así podemos ver que tenemos todas las filas aquí contienen Angus Young. Y vamos a quitarnos o limitar la declaración aquí y una reejecución esto y desplazarnos por unos resultados, podemos ver ahora tenemos más resultados de los que todos contienen Angus Young. Y de hecho, en todos estos casos, Angus Young es la primera parte de esta entrada aquí. Por lo que técnicamente también podríamos simplemente quitarle este símbolo por ciento aquí. Y seguiríamos obteniendo el resultado porque nunca hay nada que va a estar al frente, al
menos en este caso, pero no podíamos estar seguros de eso de antemano. Y si querías mantenerte a salvo, aún
podemos dejar esto aquí por si acaso más tarde en un registro se introduce donde Angus Young no es el nombre de pila dentro. Pero, ¿qué pasa si le quitamos este último símbolo por ciento aquí? Bueno entonces, ahora no vamos a conseguir nada devuelto porque ninguno de los discos termina con Angus Young y ya no dejamos la opción de tener otros personajes después. Por lo que necesitamos, en este caso, asegurarnos de que tengamos otros personajes después. Sólo para asegurarse de que haya casos donde en la cuerda Angus Young esté contenida dentro, pero también hay espacio para que otros valores también estén contenidos dentro del mismo elemento aquí. Ahora, también hay un personaje salvaje diferente que podemos usar. En lugar de usar el porcentaje, que básicamente pierden espacio para cualquier número de personajes, podemos poner algo así como un guión bajo. Ahora el subrayado significa que puede haber un solo personaje aquí. Entonces, por ejemplo, vamos a reemplazar este y por un subrayado. Y si ejecutamos esto, vemos que todavía vamos a obtener el mismo resultado porque estamos buscando donde tenemos el espacio angus. Y entonces este subrayado aquí significa que cualquier personaje, cualquier personaje puede estar aquí, no demasiado, tiene que ser exactamente uno. Y es en este caso, tenemos la y aquí, y luego tenemos la OU y g Si nos quitamos el espacio aquí, ya no funcionaría. Porque ahora ya no tenemos un solo personaje aquí. Pero podríamos poner un símbolo por ciento aquí, lo que significa que hay cualquier número de caracteres también puede ser entre aquí. Sólo necesitamos tener en algún momento a Angus. Y luego después necesitamos tener. En este punto. Para que puedas ver que hay diferentes opciones para nosotros. Uno de ellos va a ser el guión bajo, que nos permita reemplazar, simplemente tener la opción de tener un carácter libre. Y entonces que tenemos los percéntimos, que nos permiten tener la opción de tener el mayor número de personajes allí posible. Ahora mientras estamos haciendo todo esto, la capitalización en realidad es muy importante. Si cambiáramos esto para que sea minúscula, ya no
funcionaría porque ya no tenemos exactamente este partido. Entonces lo que podemos hacer sin embargo, es que podemos usar una declaración diferente aquí llamada me gusta, que significa que es insensible a los casos. Entonces en este caso, no le importa si hay letras mayúsculas o minúsculas. Y solo mira si tenemos esta coincidencia de texto y no considera casos, es insensible a mayúsculas y minúsculas. Y así podemos ver en este caso vuelve a funcionar porque todavía tenemos el texto aquí. Pero esta vez usando la IA por igual fueron en realidad ir en mayúsculas insensibles. Entonces estamos ignorando si todo es mayúscula o minúscula. Y sólo estamos consiguiendo el partido donde el texto es el mismo. Y se puede ver aquí podemos capitalizar el G, por ejemplo. Y aún tendremos el mismo partido. Porque todo aquí dentro o el emparejamiento que estamos haciendo de aquí a aquí va a ser insensible a mayúsculas y minúsculas. Ahora en algunos casos, puede
que no estemos buscando coincidencias de texto como esta, pero estaríamos buscando un cierto número de valores. Por ejemplo, echemos un vistazo atrás a nuestras pistas aquí. A lo mejor algo que queremos son todos los temas donde el ID del álbum es o sea uno o fueron el ID del álbum es de cuatro. Entonces buscamos dos casos. Queremos ambos álbumes 14 o todos los temas que son de Al my d1 y ID de álbum para. Entonces, ¿cómo podemos hacer eso? Bueno, antes que nada, vamos a cambiar tu columna aquí otra vez. Vamos a decir dónde ID del álbum. Y de nuevo, tenemos que usar las comillas aquí porque nuestra Crear Tabla se definió con las comillas para las columnas. Por lo general, como dije, las comillas son opcionales. Pero en este caso, debido a que nuestra mesa era encontrar con las comillas, tenemos que usarlas. Y ahora estamos buscando los casos en los que se encuentra el ID del álbum. Y ahora las ideas del álbum que buscamos un 14. Entonces estamos diciendo que estamos buscando todas las columnas de las pistas aquí y todos los discos de
las pistas donde estos discos tienen la columna ID del álbum donde el valor está en uno o cuatro. Entonces si ejecutamos esto, podemos ver aquí ahora todos los discos que hemos devuelto tienen Album ID, ya sea uno o cuatro. Y también podemos hacer, por ejemplo, uno para informar. Y así como pueden ver, podemos expandir esto tanto como nos guste. Pero luego también hay algunos casos en los que tal vez queremos escoger un rango de números. Entonces por ejemplo, digamos que queremos encontrar todos los álbumes con ID de álbum uno a cinco. Entonces podemos hacer, por ejemplo, 12345 así y ejecutar esto, lo que nos dará nuestros resultados. Ahora bien, esto funciona, pero no es óptimo porque tenemos que escribir todos estos fuera. Y aún funciona porque aquí tenemos cinco números. Pero imagina que teníamos como 500 o incluso más o imaginando que estábamos buscando unos rangos de fechas. Nada de eso realmente funcionaría más. Y hay una mejor manera de que podamos hacer eso. Ahora, una de esas formas que ya vimos de antemano, que es usar mayor que igual o menor que o igual. Y entonces podemos encadenar condiciones juntos, que es lo que aprenderemos pronto. Pero en realidad hay otra afirmación que podemos hacer con solo llamar entre. Entonces podemos decir que estamos buscando los casos donde el ID del álbum está entre 1, no hay paréntesis aquí, y cinco. Entonces de nuevo, vamos a seleccionar todas las columnas de la tabla de pistas. Y vamos a filtrar por los discos donde los discos aquí donde una rosa aquí tiene un ID de disco que está entre 15. Por lo que ejecutando esto, podemos ver todos nuestros valores aquí están entre 15, inclusive en ambos extremos. Y ahora, como ya habrás adivinado, impresionante por la sugerencia que obtuvimos de nuestro editor SQL aquí. También podemos no hacer entre, lo que significa que sólo vamos a mirar los registros donde están los valores. El ID del álbum no están entre 15. Entonces si ejecutamos esto, vemos que todo aquí tiene valores no entre 15. Y esta declaración NOT también funciona para las otras cosas que miramos. Por ejemplo, no como. Y entonces aquí podemos hacer AC, DC. Entonces cualquier lugar donde el compositor no sea como este texto aquí, AC, DC, que nos va a dar todos los discos donde el compositor no es esta cadena ac-dc.
21. 19Joining: Por lo que ahora ya sabemos una buena cantidad de filtrado. Pero a veces incluso el filtrado que conocemos actualmente no es suficiente. A veces necesitamos hacer más. En ocasiones necesitamos unir condiciones
específicas de filtrado juntas para obtener realmente los resultados que queremos. Entonces, ¿cómo podemos hacer eso? Bueno, trabajemos en ello con un ejemplo. Tratemos de encontrar todos los discos aquí donde nuestro compositor sea igual a AC, DC y la longitud de la canción sea mayor o igual a 250 mil milisegundos. Por lo que vamos a decir seleccionar todas las columnas de la tabla de pistas. Vamos a filtrar por las filas donde el compositor. Y ahora podemos decir igual a o podemos usar como aquí. Pero vamos a usar un era igual a porque queremos igualdad exacta. Entonces vamos a decir donde los compositores iguales a AC, DC y la columna de milisegundos es
al menos mayor o igual a 250 mil milisegundos. Entonces si ejecutamos esto, podemos ver ahora nuestros resultados son todas
las canciones de ac-dc son todos los cromosomas de esta base de datos, donde aquí los milisegundos son mayores o iguales a 250 mil. Podemos por supuesto, también cambiar esto y buscar menos o igual a 0, que en este caso soy sólo nos da un disco. Podemos ver podemos usar la declaración y aquí para hacer algún filtrado. Pero hagamos esto aún más complejo. Digamos que queremos encontrar todos los casos donde las pistas milisegundos son mayores a 250 mil. Pero sólo queremos las canciones donde los bytes es menor que. Llegamos aquí, tres y luego otros tres. Entonces tenemos 10 millones es una especie del orden de magnitud con el que estamos trabajando. Por lo que queremos encontrar todas las canciones donde los bytes son menos de 10 millones. Por lo que podemos sumar si queremos. Otra condición aquí, digamos y somos bytes es menor o igual a diez millones. Y alguien puede correr esto. Y así entonces podemos ver que nos devuelven estas pistas específicas. Alternativamente, en lugar de encadenar con y también podemos usar o declaraciones. Entonces por ejemplo, busquemos todas las canciones que o se hacen o empezaremos con todas las canciones que o están hechas por AC, DC o tienen al menos 1,050,000 mil milisegundos de largo. Por lo que la declaración OR aquí significa que estamos buscando para igualar cualquiera de estas condiciones. Entonces sigamos adelante y ejecutemos esto. Y podemos ver aquí o tenemos ac-dc, en cuyo caso, como podemos ver aquí, podemos encontrar la fila. Aquí vamos. El milisegundos de columna es menor a 250 mil. O en los casos en que compositores no ac-dc, todos ellos milisegundos es al menos igual o mayor a 250 mil. Por lo que podemos ver aquí tenemos una o declaración. Ahora lo que también podemos hacer eso es genial, es que puedes seguir encadenando condiciones usando paréntesis. Entonces por ejemplo, busquemos todas las canciones donde el compositor es o ac-dc o el track es más largo de 250 mil milisegundos. Bud Es bytes también es menor o igual a 10 millones. Por lo que queremos ya sea AC, DC o al menos 250 segundos y menos de 10 millones de bytes. Entonces cualquiera de esas dos condiciones, pero luego la segunda tenemos que hacerlo. Entonces lo que podemos hacer es que aquí podemos usar paréntesis. Y entonces podemos decir, y bytes es menor o igual a 10 millones. Y entonces lo que va a pasar es que esta afirmación va a ser evaluada como una sola. Y se va a comparar con éste. Entonces o tenemos ésta o tenemos el resultado aquí donde se necesitan cumplir ambas condiciones. Para que veas que hay mucho que puedes hacer con un filtrado usando el y en el orden, además de usar paréntesis para decidir qué condiciones se deben unir. Ahora, por supuesto actualmente sólo usamos cosas como igual o mayor que igual o menor que igual a. Pero esto también funcionará igual de bien si ponemos aquí, por ejemplo, similares, o si ponemos ahí dentro en un rango, todo funcionará igual. Podemos usar las otras palabras clave que también aprendimos en donde las declaraciones aquí, y también seguir cambiando las condiciones usando los remos, usando los ands y poniendo paréntesis alrededor de las condiciones que queremos
agrupar como un paréntesis o más bien que queremos agruparnos como una sola unidad. Y también podemos seguir encadenando paréntesis. Entonces por ejemplo, aquí dentro, podemos entonces poner otro paréntesis y hacer algunas cosas más, por ejemplo, y bytes es menor a 10 millones. O no sé, pensemos en algo o un compositor es como. Y entonces en realidad vamos a mover esto a una nueva línea para hacer este más limpio y mover esto a una nueva línea. Y el compositor es como Angus Young. Observe que estamos usando la luz aquí, no la me gusta, así que necesitamos usar la carcasa correcta. Entonces en este caso, y asegurémonos de cerrar los paréntesis 2. Estamos buscando ya sea donde el compositor sea como ac-dc, o donde los milisegundos sean mayores o iguales a 250 mil y nuestras mordidas sean menores a 10 millones. O los compositores como Angus Young. Entonces vamos a ejecutar esto para ver los resultados. Y entonces lo que hacemos aquí, Vayamos hacia atrás. O comprobamos por el, primer lugar, tenemos la condición aquí fuera. Entonces todo lo que es ac-dc va a estar aquí. Pero ahora lo que tenemos aquí es, vale, o
estamos buscando menos o igual a 10 millones de bytes o el compositor necesita tener a Angus Young en ella. Y entonces si cualquiera de estos dos es cierto, también
necesitamos encontrar que los milisegundos es mayor o igual a 250 mil. Entonces por ejemplo, podemos ver en este registro aquí, tenemos los bytes siendo mayores a 10 millones. Pero nuestro compositor es como Angus Young. Por lo que se cumple esta parte de la condición, lo que hace cierta esta o afirmación. Este de aquí. Entonces éste es cierto. Ahora necesitamos que éste y éste sea cierto. Lo que significa que nuestros milisegundos necesitan ser mayores o iguales a 250 mil, que es lo que tenemos aquí. Entonces tenemos, éste es cierto, y éste es cierto. Ahora necesitamos decir o usar compositores como AC, DC, que es falso, o donde todo este segmento aquí era cierto, lo
cual no es este caso. Entonces podemos ver podemos hacer lógica bastante complicada usando el filtro
aquí adentro encadenando juntos son diferentes operaciones como, como V igual a IR Me gusta en medio, además de usar los ands y los ors y hacer paréntesis para agrupar cosas que queremos tener agrupadas.
22. 20NegatingHB: Muy bien, así que ahora hemos visto un montón de filtrado donde las condiciones son verdaderas. Pero en algunos casos queremos que las condiciones no sean ciertas. Ahora como que ya hemos visto esto, pero vamos a echarle otra mirada un poco más detallada. Entonces volviendo a nuestra tabla de temas aquí, primero que nada,
solo busquemos todos los casos donde Composer es un no igual a AC, DC. Entonces lo que podemos hacer aquí, puedes seleccionar, solo tienes que seleccionar todas nuestras columnas de la tabla de pistas y conocer al compositor. Y ahora tener no es igual, y podemos tener un signo de exclamación igual. Y entonces aquí vamos a poner el texto ac-dc. Entonces esto nos va a dar todos los discos donde el compositor no es igual a AC, DC, como podemos ver aquí, ninguno de estos registros que contengan CDC. Y lo que también podríamos hacer aquí porque tenemos texto aquí. Entonces podríamos decir que no como ACC, lo que significa todos los casos en los que no es como este texto aquí, que nos va a dar el mismo resultado en este caso. Ahora también podemos hacer otras cosas. Por ejemplo, no entre, que como hemos visto. Entonces podemos decir que no entre. Y queremos decir porque en este caso entre no tiene mucho sentido para la columna del compositor ya que todo es texto. Entonces usemos el ID del álbum. Por lo que queremos encontrar todos los discos donde el ID del álbum no está entre 46. Entonces eso nos va a dar todos los discos aquí son disco ID no está entre 46, así que no cuatro, ni cinco, ni seis, y todo lo demás que vamos a conseguir. O también podemos hacer nada aquí. Y luego poniendo nuestros paréntesis, lo que significa que nuestro ID de disco no está en 46, lo
que significa que no es igual a 46. Entonces si corremos este riesgo ahora vamos a conseguir ID de disco cinco porque no los estamos usando entre, pero ahora estamos haciendo coincidir específicamente las instancias de aquí. Entonces podemos ver que podemos usar el no igual a dos, por ejemplo, así para hacer negación por el caso de igualdad. Y podemos hacer la declaración NOT para algunos de los otros más complejos donde los métodos que tenemos. Ahora puedes, tal vez te estés preguntando, bueno, ¿qué tal opuesto de mayor que igual a? ¿ Cómo podemos negar eso? Bueno, ya tenemos una declaración para aquello que es el menor que. Por lo que podemos decir cualquier cosa que no sea mayor que o igual a va a ser menor que. Y todo lo que no es menor
que, puede ser mayor que o igual a. Y entonces podemos conseguir lo mismo, viceversa. Ahora una cosa más que quiero añadir aquí, si solo volvemos a algunos de nuestros resultados previos para el medio, es en algunos casos en realidad quizá queramos pedir nuestros resultados también. Entonces, veamos los resultados de esto. Tienes nuestro ID de disco no está entre 46. ¿ Necesitaba volver más allá? Otra vez con problemas? Está bien. Raro. Parece estar bien. Entonces ordenemos todo por nuestro ID de álbum aquí. Entonces el enunciado orden BY que ya hemos aprendido, pero en realidad tiene que haber un orden específico a las ubicaciones donde estamos colocando estas sentencias SQL. Por lo que SARSA seleccione y tenemos el de. En este caso vamos a tener el dónde y el orden por va a venir después. Entonces, por ejemplo, queremos ordenar por ID de álbum en orden descendente, lo que significa más alto primero. Entonces si ejecutamos esto, puedes ver que empezamos con el ID de álbum más alto e ir hacia el más bajo. Ahora es importante que este orden BY venga después de la declaración where. Porque si lo ponemos antes de la declaración donde, entonces vamos a tener un error porque, bueno, vamos a correr todo porque no pertenece ahí. Ese no es el orden correcto de la sintaxis SQL. Por lo que Dasa viene después. Ahora también, lo mismo con la declaración de límite. El comunicado de límite tiene que llegar al final. Por lo que todo lo que hemos aprendido para este orden BY declaraciones sigue cierto porque todavía hacen pedidos adicionales haciendo comas aquí. Pero es importante que el orden en el que estamos haciendo estos comandos esté en este orden específico. En este caso, se va a empezar con select y desde el enunciado where, luego el orden BY y luego tenemos el límite porque si está en otro orden y no va a funcionar.
23. 21FilteringNullValuesHB: Ahora hay un caso especial más de filtrado que aún no hemos mirado. Entonces echemos un vistazo de nuevo a nuestra mesa de compositor aquí. Algunas de estas instancias pueden tener valores faltantes, los cuales se representan aquí como valores nulos. Por lo que actualmente, no hay forma real de que sepamos revisar por esto todavía. Entonces, echémosles un vistazo. Entonces, primero que nada,
seleccionemos todas nuestras columnas de nuestra mesa de camiones, filtrando para los registros donde el compositor. Y ahora queremos decirlo todo. Queremos encontrar todos los casos donde el compositor es nulo aquí. Entonces para hacer eso, en realidad tenemos que escribir es nulo. Y luego un punto y coma solo para terminar un poco o consulta SQL aquí y luego golpear una carrera. Y así ahora obtenemos todos los casos donde el valor aquí en la columna del compositor es nulo. Ahora, lo importante es que no hagamos eso igual aquí, porque esto no es correcto. Queremos asegurarnos de que lo hacemos es nulo. Esa es la declaración correcta a usar. Ahora por negación, va a ser bastante simple y tal vez ya
lo viste en la sugerencia de código. Todo lo que tienes que hacer es escribir NO ES nulo. Y eso nos va a dar todos los casos donde no se conoce al compositor. Y así esto de nuevo va a funcionar como cualquier otro condicionamiento que hemos tenido aquí. Nuevamente, en este caso, sólo tenemos un caso especial para usar cuando no hay valores contenidos dentro. Pero todo lo demás que hemos aprendido sobre el lugar donde la declaración sigue siendo verdadera.
24. 22Creacióny columnasy 22CreatingNewColumnsAndArithmeticsHB: Entonces en esta lección, echemos un vistazo a cómo podemos hacer algunas operaciones en nuestras columnas. Abramos de nuevo nuestra tabla de temas aquí. Y lo primero que debemos hacer es intentar
convertir esta columna de bytes en su lugar a kilobytes. Entonces para hacer eso, vamos a dividir todo aquí por 1024. Entonces, ¿cómo podemos hacer eso? Bueno, volviendo a nuestra consola, vamos a escribir select, y luego dejaremos estrella aquí como plantilla por ahora, pero volveremos y cambiaremos eso en un segundo. Seleccionamos estrella de pista. Y también limitemos nuestros resultados a cinco por ahora, si
acaso tipo de buenas prácticas o nuestras mesas ahora tubing aquí. Pero por si acaso tuviéramos millones de filas o algo así, sería bueno probar y solo devolver un pequeño segmento de esas filas. Muy bien, así que vamos a escoger por ahora y solo la columna de bytes. Y vamos a convertirlo también dos kilobytes. Entonces la primera columna que queremos sacar va a ser picaduras. Y la segunda columna que queremos sacar es de nuevo la columna bytes. Pero aquí queremos dividirlo, dividirlo por 1024 para convertirlo en kilobytes. Así lo hacen entonces, en realidad podemos simplemente usar la barra de aquí para la división y poner en el número 1024. Y eso va a dividir los valores de esta columna aquí por 1024. Y entonces podemos usar un alias para, para hacerlo más, para darle un mejor nombre. Entonces podemos guardar esto aquí como kilobytes por ejemplo. Entonces sigamos adelante y ejecutemos esto. Y podemos ver aquí, aquí tenemos los bytes y aquí tenemos la misma cantidad, pero en kilobytes en su lugar. Ahora por supuesto, la operación de división no es lo único que podemos hacer. También podríamos hacer otras cosas como, y tal vez, vamos a crear algunas columnas nuevas para esto. Entonces multiplicemos nuestras mordeduras. Se puede multiplicar por dos, por ejemplo. Y aquí podemos guardar esto como bytes multiplicados solo para poder diferenciarlos. Podemos hacer restas. Por ejemplo, podemos tomar nuestras tuberías y restarle algo. Y entonces aquí podemos llamar a este sub bytes para bytes restados. Y luego hagamos también el otro, que va a ser una adición. Y aquí esto van a ser nuestros bytes añadidos. Entonces solo voy a poner algunos espacios aquí para que todo el formateo sea agradable. Entonces si ejecutamos esto, se
puede ver aquí hay muchas operaciones diferentes es operaciones aritméticas
simples que podemos hacer sobre nuestras columnas. Por lo que puedes ver aquí tipo de tenemos todas las operaciones por defecto disponibles para nosotros. También podemos hacer otras cosas geniales en lugar de simplemente usar valores numéricos fijos. También podemos usar otras columnas. Por ejemplo, intentemos encontrar una nueva columna. Ese es el número de bytes por milisegundo de longitud de canción. Entonces vamos a dividir los valores en
la columna de bytes por los de la columna de milisegundos. Y luego obtenemos el número de bytes por milisegundo y la pista. Entonces para hacer eso, vamos a tomar nuestra columna de mordeduras y la vamos a dividir por la columna de milisegundos. Vamos a darle a esto un alias llamado bytes por millón. Entonces bytes por milisegundo. Y de nuevo, podemos ejecutar esto. Y podemos ver aquí ahora tenemos diferentes valores del número de bytes utilizados para almacenar la canción por milisegundo de longitud de la canción. Y no podemos hacer también otras cosas geniales aquí. Por ejemplo, podemos pedir ahora por nuestras picaduras por milisegundo si lo desea. Entonces tal vez lo primero que debemos hacer es simplemente quitarle esta declaración de límite aquí. Y vamos a correr eso una vez más para obtener los resultados completos. Y también saquemos el nombre de la pista para que realmente veamos cuál es esta pista. Y así vamos a quitar esto ahora y sólo sacar el nombre de la pista. Y no necesitamos proporcionar ningún nombre extra. No necesitamos proporcionar ninguna adición extra ni nada aquí. Porque no lo son, realmente no significan mucho aquí estas multiplicaciones son restas, pero como puedes ver, no podemos hacerlas. Muy bien, así que tenemos nuestras mordeduras tranquilas. Si ejecutamos esto, tenemos nuestros kilobytes, tenemos el nombre de la canción y también los bytes por milisegundo. Entonces sigamos adelante y ordenemos nuestros resultados por los bytes por milisegundo en orden ascendente. Ya vamos a pedir. Podemos tener diferentes formas. Entonces, por ejemplo, podemos ordenar por cuatro ser la forma más rápida. Y es un poco fácil de ver aquí porque ahora todavía es fácil contar el número de columnas que tenemos. También puedes pedir por bytes por mililitro si queremos. Entonces podemos ver aquí obtenemos los mismos resultados o realmente podemos repetir la operación y ordenar por bytes por milisegundos así. Este es, con mucho, el menos ideal. Probablemente. Es mucho mejor usar el alias de columna real que asignaste aquí arriba. Pero sólo para mostrarles, podemos hacer esto y si también podemos hacerlo en orden descendente, claro. Entonces ahí vamos. Ahora podemos ver que hay diferentes formas de hacer tipos de operaciones aritméticas simples, tanto con tipo de valores naturales como también usarla entre diferentes columnas. Ahora, hagamos otra cosa. Porque también aquí podemos hacer esto más complejo agregando en cosas como paréntesis. Entonces vimos que cuando estamos haciendo uniendo condicionales y donde teníamos la opción de usar ands y ors así como paréntesis. Podemos hacer lo mismo aquí. Entonces tomemos algo y tomemos nuestra identificación de camioneta. Y agreguemos en él el id del álbum multiplicado por el tipo de medio ID. Entonces aquí por ejemplo, vamos a llevarnos nuestra identificación de camión. Y luego vamos a sumar. Y luego podemos tomar nuestro ID de álbum más el ID de tipo de medio,
veces el ID de tipo de medio. Ahora esto no, esto realmente no significa tanto, sino sólo para mostrarles que podemos hacer todo esto. Entonces en primer lugar aquí tenemos una simple adición y multiplicación. Y esto sólo podemos llamar ahora mismo como columna personalizada. Y vamos a seguir adelante y ejecutar esto. Podemos ver aquí obtenemos los resultados de lo que sea que sea. Pero si usamos paréntesis, en realidad
podemos hacer operación r plus primero, y luego podemos hacer nuestra operación de multiplicación. Entonces al igual que hicimos para nuestros condicionales donde podemos usar paréntesis, también
podemos hacer exactamente lo mismo aquí para usar paréntesis. Y entonces podemos ver obviamente ahora esta cosa va a ser evaluada como una sola unidad. Y entonces se va a multiplicar el resultado de esto. Por lo que como pueden ver, también podemos hacer modificaciones a nuestras columnas aquí. Hacer divisiones de columna son una especie de dividir una columna por la otra. También podemos multiplicar columnas entre sí. Podemos agregar columnas entre sí, y también podemos usar paréntesis para
dictar tipo de operaciones que queremos usar.
25. 23DatatypeConverstionsHB: Ahora, anteriormente vimos que podemos hacer, por ejemplo, divisiones aquí. Y eso lo hicimos dividiendo nuestra columna de mordeduras por un 1024 para convertirla en kilobytes como vemos aquí. Pero probablemente te diste cuenta, o probablemente al menos te preguntaste, que dividir todas nuestras mordeduras, siempre comprar un 1024. Es muy poco probable que siempre vamos a obtener valores enteros perfectos aquí. Y tienes toda la razón. No es muy probable. Y muchos de estos son en realidad números de punto flotante son, muchos de estos son números reales o números decimales. Pero se han convertido en enteros porque tenemos un entero aquí y un entero aquí. Entonces estamos haciendo divisiones enteras. Entonces en esta lección vamos a ver cómo podemos cambiar nuestros tipos de datos para que sean valores diferentes. Ahora en este caso, va a ser bastante fácil porque una cosa que podemos hacer es que podemos cambiar nuestros 1024 para ser 1024. Y eso lo va a cambiar de un entero a un número decimal. Entonces si ejecutamos esto, podemos ver aquí ahora realmente tenemos decimal está incluido en nuestras divisiones. Y así podemos ver los resultados aquí. Obviamente tienen números decimales, mientras que de antemano sólo los teníamos redondeados al entero más cercano. Pero también hay diferentes formas en que podemos hacer esto. Y como no siempre vamos a estar usando números codificados como este. Pero muchas veces quizá queremos referirnos a columnas
específicas o queremos cambiar los tipos de columnas. Esto no siempre es posible. Entonces, por ejemplo, no podemos hacer lo mismo con la columna bytes. No podemos simplemente poner un 0 aquí. Y se puede ver que si ejecutamos esto, vamos a tener un error porque de nuevo, esto no va a funcionar. Entonces hay otras formas en las que podemos acercarnos a hacer lo mismo aquí. A esto se le va a llamar mecanografiado. Entonces lo que podemos hacer es, y probemos esto en la columna bytes. En primer lugar. Podemos lanzar, podemos lanzar nuestras mordeduras. Y luego ponemos aquí la palabra clave As. Y luego vamos a poner aquí el tipo de datos. Y así ahora podemos lanzar nuestra columna y cambiar el tipo de datos. Por ejemplo, podemos cambiarlo actualmente es entero predeterminado, que podemos ver también si abrimos esto y miramos los bytes, podemos ver que es un entero aquí. Por lo que podemos fundar, por ejemplo, para ser un tipo de datos real. Entonces si ejecutamos esto y en este caso, nuestros resultados no van a cambiar sólo por la forma en que se muestran. Pero nuestros valores aquí es en realidad ahora un tipo real. Entonces vamos a aplicar lo mismo abajo abajo y en realidad ver algunos resultados. Entonces vamos a lanzar nuestro número 124 en su lugar para estar en un número real. Entonces vamos a echar 1024 Como número real. Entonces este aquí no va a ser un número real aquí abajo. Entonces si ejecutamos esto, se
puede ver aquí ahora otra vez tenemos esta división de coma flotante. Nuevamente ahora tienen decimales. Y los tipos de datos que podemos poner aquí son
los tipos de datos que aprendimos en la lección de intro. Por lo que puedes lanzar a cualquiera de los tipos de datos que están disponibles para nosotros. Para que podamos hacer el casting así. Y como pueden ver, podemos, podemos emitir en enteros individuales. También podemos echar sobre columnas completas. Por ejemplo, como vimos arriba. Podemos lanzar nuestras mordeduras también para ser un tipo de datos de número real. Entonces si ejecutamos esto y podemos ver estos son los resultados que vamos a conseguir. Ahora. Todos ellos que estamos haciendo aquí es cambiar el tipo de datos. Ahora una forma de hacerlo, nuevo es usar aquí la declaración CAS. Pero otra forma de hacerlo es, y lo mostraré primero en nuestro 1024, pero esto que funciona en todas partes también. También podemos lanzar esto usando esta sintaxis. Entonces vamos a poner dos colones. Y entonces aquí podemos poner el tipo de datos al que queremos echarlo. Entonces ejecutándolo así. Se puede ver aquí, o teniendo esto, ambos son equivalentes. Bueno, trillón, ambos son equivalentes. Por lo que hay diferentes formas en las que podemos lanzar. Una de ellas es lo que acabamos de ver, que es el elenco como el otro está usando estos dobles puntos, lo que nos permite lanzar el valor frente a este nuevo tipo de datos. Por lo que también podemos hacer esto, por ejemplo, a nuestras mordeduras aquí. Pero vamos a convertir esto en un texto. Porque ahora vamos a tener un problema, ya que estamos tratando de dividir texto por valor numérico y esa operación no está definida. Entonces podemos ver aquí, podemos lanzar tanto los valores individuales que ponemos aquí, que por supuesto no van a ser tan útiles. Pero también podemos lanzar valores completos o nuestras columnas completas, pero también podemos lanzar nuestras columnas completas dos tipos de datos diferentes. Y para que eso pueda ser realmente agradable para diferentes operaciones. O también si eres tipo de datos y las columnas el valor incorrecto. Por ejemplo, si estás almacenando un valor numérico en su lugar como una cadena, entonces si estás tratando de hacer divisiones, no funcionará Incluso si lo tienes. Por ejemplo, veamos, bueno, tomemos esto y lo convertimos a texto. Y luego si también convertimos esto a texto, entonces esto va a ser un problema para nosotros porque no podemos dividir texto por texto. Entonces en esos casos, lo que podemos hacer es echar nuestros textos valores, dos enteros, por ejemplo. Podemos hacer lo mismo aquí. Queremos tener esto fuera y bytes de cliente aquí, dos enteros. Y así en algunos casos cuando los tipos de datos se estropean en nuestra base de datos, por ejemplo, o también cuando queremos hacer conversiones de tipo de datos por diferentes razones, podemos usar casting con las dos sintaxas. Uno de ellos es este doble colon, y uno de ellos es este elenco como sintaxis de tipo de datos. Y así también tenemos más flexibilidad al tratar los tipos de datos así como al cambiar a diferentes tipos de datos.
26. 24LogicStatementsHB: Ahora, en algunos casos, también quizá
queramos incluir sentencias lógicas en las consultas SQL. Entonces, veamos un ejemplo sencillo de cómo podemos hacer eso. Tomemos nuestra mesa de atletismo aquí otra vez. Y volvamos a pasar por los compositores. Y ahora vamos a hacer una nueva columna que básicamente diga sí o no si el compositor es AC, DC. Entonces, echémosles un vistazo. Sigamos adelante y en primer lugar, solo seleccionamos todo de nuestra columna de camiones y solo limitamos nuestros resultados a cinco. Algo así como tener este código esqueleto aquí porque después de eso puedes volver y cambiarlo. Entonces sólo para tener aquí el esqueleto. Entonces lo primero que vamos a hacer es elegir al compositor, qué columna, sólo para que tengamos el verdadero valor con el que comparar. Y ahora queremos hacer una nueva columna. Y podemos llamar a eso, por ejemplo, es AC, DC, que va a ser sí. Cuando nuestro compositor aquí es AC, DC y va a ser no de otra manera. Entonces, ¿cómo podemos hacer eso? Podemos usar la declaración de caso que forma parte de nuestro, eso es parte de SQL. Entonces podemos decir caso cuando compositor es igual a AC, DC, entonces sí más, no. Y entonces vamos a ahorrar eso como ac-dc. Entonces echemos un vistazo a esta declaración completa aquí. La palabra clave case indica que vamos a empezar aquí una declaración de caso. Y luego tenemos la palabra clave one que dice cuando esta condición, entonces hacemos lo siguiente. De lo contrario, tenemos esto. Ahora hay una cosa más que nos falta al final de cada declaración de caso. Una vez que terminemos con todos nuestros casos, hay que poner fin aquí. Por lo que comienza con caso cuando compositor es igual a AC, DC. Y ahora ya vimos esta comparación cuando estábamos mirando el filtrado, específicamente las declaraciones donde. Entonces sí caso cuando compositores ac-dc, entonces el valor va a ser SÍ. De lo contrario, el valor va a ser no. Fin para indicar que este es el final de nuestra declaración de caso. Entonces, vamos a ejecutar esto. Y podemos ver aquí tenemos dos columnas. Entonces el primero son nuestros compositores aquí. Y actualmente estamos limitando nuestros resultados. Entonces sigamos adelante y quitemos esta declaración de límite y pasemos por algunos resultados más para que puedas ver todo donde no es igual a AC, DC que hemos conocido. Y cuando es igual a AC, DC, tenemos, sí, como podemos ver aquí. Está bien, genial. También podemos por supuesto, dividir esto en varias líneas para que sea más fácil de leer para que no lo sepamos, repasar tantas líneas. Entonces podemos hacer algo así, por ejemplo. Y todavía nos va a dar los mismos resultados. Ahora, también podemos hacer más cosas. Por ejemplo, en lugar de tener sólo 11 declaración, también
podemos tener varios. Entonces digamos que queremos tener un cheque separado y volver a comprobar cuando el compositor es como. Y ahora vamos a usar la declaración ligera que también vimos antes. Y aquí vamos a buscar a Angus Young, en cualquier lugar de ahí dentro. Entonces vamos a decir Tal vez más, no. Entonces volvamos a ejecutar esto. Y podemos ver aquí en el caso donde Angus Young está dentro, tenemos tal vez en el caso donde ni Angus Young ni AC DC está dentro. TENEMOS NO. Y de lo contrario cuando AC, DC está dentro, entonces tenemos sí. Ahora lo importante a tener en cuenta también aquí es aunque tenemos un orden específico. Entonces primero buscamos esta declaración, luego buscamos esta declaración. Y esta aquí va a ser nuestra declaración de reserva. lo tanto, dependiendo del orden en el que los pongas, tus resultados pueden o no cambiar dependiendo exactamente qué comparaciones estés usando. Ahora en este caso, usamos la declaración igual y la luz. Pero por supuesto también hemos visto otras afirmaciones que podemos usar para comparación cuando estábamos pasando por el filtrado específicamente. A lo mejor para limpiar esto un poco más. Voy a poner en las mismas líneas las declaraciones cuándo y Venn. O también puedo dividir cada uno de estos en líneas separadas, solo algo que hace que sea intuitivo de leer, pero también algo que impida que nuestras consultas SQL
simplemente huyan demasiado ajenas a la horizontal, que de nuevo tampoco lo hace muy legible. Entonces podemos ver que tenemos muchas opciones diferentes usando las declaraciones de caso. Y también podemos hacer otras cosas. Por ejemplo, no necesitamos poner un valor de texto aquí. Podemos tener aquí, por ejemplo, el 1. Aquí, podemos tener tal vez 0.5. Y de lo contrario podemos poner 0. Y podemos ejecutar esto y podemos ver los resultados aquí. Entonces podemos ver que no nos limitamos a poner sólo texto. No obstante, los tipos de datos que elegimos sí tienen que ser compatibles entre sí. Por ejemplo, algo que no va a funcionar es si ponemos aquí, tal vez porque ahora no sabe qué tipo de datos elegir. Entonces puedes ver aquí está tratando de usar un entero, pero luego cuando se encuentra con el texto y simplemente se confunde. Así que solo asegúrate de que los tipos que estás usando sean compatibles entre sí. Como puedes ver aquí, todos estos van a ser reales como números. Entonces todo eso debería funcionar bien. De lo que vamos a estar usando textos de antemano. Y por supuesto, podemos encadenar, seguir encadenando estas declaraciones condicionales si queremos, dependiendo de otras cosas que busquemos. Y podemos volver a utilizar estos operadores de comparación, que también vimos antes. Entonces lo que es genial de las declaraciones de caso es que ahora tenemos una manera y lógica en nuestras consultas SQL. Y de nuevo, estas van a estar creando nuevas columnas para nosotros. Y estas nuevas columnas contienen valores que se componen
específicamente de declaraciones de caso que hemos definido aquí. Nuevamente, la sintaxis importante es que tenemos un caso para indicar reiniciar la declaración de caso. Entonces, uh, cuando yo para indicar que estamos empezando la comparación o condicional aquí, entonces tenemos el condicional real que estamos buscando. Si este condicional es cierto, entonces tenemos esta palabra clave. Vamos a asumir este valor. Este condicional no es cierto. Vamos a pasar a la siguiente, a la siguiente declaración. Si hay una declaración X1, mire este condicional. Si esta condición es cierta, entonces vamos a asumir este valor y vamos a
seguir adelante a través de cada condicional que tengamos. Si tenemos aún más cuando. Y luego declaraciones aquí abajo. Y luego seguiremos pasando por todos estos. Y si todos estos fracasan, entonces vamos a volver a esta afirmación else, que es cuando todo lo anterior falla, entonces vamos a asumir este valor. Y luego vamos a guardar o columna dándolo. Y este alias, como podemos ver aquí.
27. 25Manipulación: Entonces en esta lección, echemos un vistazo a cómo podemos hacer algunos recortes de texto. Entonces echemos un vistazo a algunas de nuestras columnas. Y de nuevo, especie de por defecto volver a la columna del compositor, que hemos estado usando mucho en estas tabla de temas aquí. Tratemos de sacar el a al inicio de cada disco aquí. Entonces para hacer eso, vamos a seleccionar solo escribir nuestro esqueleto, todo desde pista. Y limitemos,
limitemos nuestros resultados a cinco por ahora. Entonces, de nuevo, lo que queremos es que el compositor solo se compare,
para asegurarnos de que todo funcione correctamente. Y ahora lo que queremos hacer es tomar la columna del compositor, pero queremos quitar si hay una, la a al principio. Entonces, ¿cómo podemos hacer eso? Bueno, hay un SQL muy cool, hay una característica SQL muy cool que podemos usar llamada L Trump. Y entonces lo que podemos hacer aquí es que vamos a poner el texto o recordarlos aquí. Y luego también vamos a poner el valor que queremos recortar lejos del lado izquierdo. Entonces, por ejemplo, si queremos recortar la a, entonces vamos a poner aquí VA. Y entonces podemos darnos un alias, por ejemplo, columna recortada. Está bien, así que vamos a ejecutar esto. Y ahora podemos ver, está bien, tenemos a nuestro compositor. Y si tenemos aquí nuestra columna de recorte, tenemos todos los casos donde hay un a en el frente. Tenemos la a recortada. Entonces, quitemos nuestra declaración de límite y veamos los resultados completos. Entonces podemos ver en cualquier momento hay, por ejemplo, Angus Young, se
puede ver que se quita cuando hay ac-dc, podemos ver que se lleva la a. Y otros casos aquí, nuevo, se le quita la a. Por lo que podemos ver las miradas de ribete V L para este personaje aquí en el lado izquierdo. Y si ahí existe, se lo va a quitar. Ahora podemos extender más esto. Y si ponemos aquí, por ejemplo, múltiples caracteres como AC, entonces por supuesto los resultados van a cambiar porque Angus Young, por ejemplo, no contiene un C, pero el a es, podemos ver aquí todavía está recortado lejos. Entonces hay una cantidad específica de recorte que podemos hacer es que podemos ver desde el lado izquierdo de lo importante a tener en cuenta aquí es que el recorte que estamos haciendo es sensible a mayúsculas y minúsculas. Entonces si lo ponemos aquí minúscula a, entonces no va a pasar nada. Porque de nuevo, estamos haciendo cosas sensibles a mayúsculas y minúsculas. Entonces necesitamos recordar eso, que lo
que estamos usando aquí va a ser sensible a mayúsculas y minúsculas. Ahora también por supuesto tenemos la opción de hacer un recorte de escritura y rtrim. Y vamos a quitarnos, por ejemplo, la n, que la n al final de Johnson sea quitada. Y así si ejecutamos esto, podemos ver que ahora se quitan todos estos. Dondequiera que haya una n al final mismo. Ahora no te he quitado. Simplemente desplazándose por
esto, parece que Johnson es el principal. Por lo que puedes ver los resultados aquí. Cualquier caso donde haya un n al final, ahora no se
lo quita. En caso de que no queramos especificar si enviamos B, la izquierda o la derecha, y solo queremos eliminar caracteres extra a ambos lados. Entonces podemos hacer esos con sólo usar trim. Lo que significa que lo va a hacer, si encuentra este personaje a ambos lados, se lo va a quitar. Entonces si ejecutamos esos son resultados todavía van a ser principalmente lo que teníamos antes, solo también porque tenemos resultados sensibles a mayúsculas y minúsculas. Entonces en este caso, es poco probable que alguno de nuestros compositores. Aquí, vamos a empezar con una n minúscula, pero aún tenemos la opción de quitárselo a ambos lados. Y lo que también podemos hacer en realidad es que podemos encadenar operaciones. Por ejemplo, podemos ejecutar primero el recorte, que busca el N de cualquiera de los lados en términos que se aleje. Y luego si queremos, entonces podemos ejecutar un recorte L en los resultados. Entonces, por ejemplo, digamos que recortamos la n. Y entonces lo que queremos recortar es, digamos v a del lado izquierdo. Entonces lo que vamos a hacer es primero vamos a ejecutar la declaración aquí. Y luego vamos a conseguir aquí la columna resultante, que es, por ejemplo, lo que teníamos aquí, Angus Young y luego el Johnson no pasó n Y entonces
vamos a ejecutar el recorte L en el resultado aquí, esta vez buscando dar la vuelta a la mayúscula a por el lado izquierdo. Por lo que poder encadenar estas operaciones juntas es por supuesto muy agradable y muy útil. Y en algunos casos vas a hacer esto. Por ejemplo, si tus valores de fecha están algo mal o en un formato extraño y tal vez haya espacios
extra o relleno extra está alrededor de algunos valores de texto. Y puedes simplemente deshacerte de toda esta basura que se supone que no debe estar ahí para asegurarte de que tus datos estén en un formato más estándar. Por lo que la mayoría de las veces estarás usando esto para hacer algún tipo de procesamiento en tu columna en caso de que los datos tengan algún relleno extraño a su alrededor. O simplemente quieres quitarte algunas cosas innecesarias que no deberían estar ahí para que tus valores sean realmente más limpios. Ahora, otras dos cosas geniales que también podemos hacer para solo procesar un poco nuestros textos, es que podemos hacer algo de casting. Podemos lanzar estos ya sea a mayúsculas o minúsculas. Esto puede ser realmente agradable porque desde entonces muchas veces estamos lidiando con sensibilidad
de mayúsculas y minúsculas. A lo mejor en puntos, realmente no nos importa si Angus Young es escrito mayúscula un MGUS o si está escrito en minúscula, un MGUS son todos mayúsculas o todas minúsculas. A veces realmente no queremos lidiar con estas cosas de sensibilidad a los casos. Entonces una buena solución a esto es simplemente lanzar todo. Estamos convirtiendo todo en mayúsculas o minúsculas. Entonces para hacer eso, podemos usar la palabra clave opera. Y pongamos aquí otra vez una columna de compositor. Demos a esto el alias, y pongamos un espacio aquí solo para que sea más legible como compositor superior. Y luego también vamos a lanzar a minúsculas, lo cual podemos hacer usando la palabra clave inferior, nuevamente usando la columna del compositor. Y entonces esto lo podemos tener aquí como compositor inferior. Entonces ejecutando esto, podemos ver aquí ahora tenemos el término declaración que teníamos antes, la columna original, todo convertido a mayúsculas y todo convertido a minúsculas. Entonces aquí podemos, por ejemplo, probar
también después de que convertimos todo en minúsculas. Echemos un vistazo a recortar cualquiera de los ácidos. Por supuesto, vamos a asegurarnos de que estamos usando minúsculas S nosotros aquí, ya que todo aquí dentro va a ser minúscula. Entonces eso debería quitarle el, si sólo echamos un vistazo aquí, la S está al frente aquí. Y luego tenemos también las carreteras Taylor. Por lo que también se debe llevar aquí la S al final. Entonces sigamos adelante y ejecutemos esto. Y podemos ver en este caso, ambos Ss se llevan. Nuevamente, esto puede ser realmente útil cuando puede haber algún relleno o algunas otras cosas alrededor de tus datos y quieres hacer algún procesamiento en tus cadenas, solo poder quitarte algunos de estos valores. Ahora podemos combinar esto, por ejemplo, a lo que aprendimos con el casting. Y digamos que queremos quitarle v dot 99 al cada, al final de cada precio unitario aquí. Entonces lo que podemos hacer es simplemente decir, de acuerdo, así que tomemos nuestro precio unitario y vamos a convertir esto a texto. Y luego aquí
vamos a recortar desde el MOOC, nuestro recorte desde el lado derecho, el punto 99, ya que esto ahora va a ser valores de texto. Y luego si queremos, no tenemos que hacerlo, pero si queremos, podemos convertir esto de nuevo a un entero. Entonces recuerda que podemos usar el doble colon o también puedes usar el como declaración. Y entonces aquí podemos hacer el elenco. Y para demostrar que se trata de un entero, podemos agregar, por ejemplo, más uno. Y entonces este año podemos ahorrar como precio unitario recortado. Entonces podemos correr esto y sólo echar un vistazo al lado derecho aquí. Entonces lo que hicimos es convertir o un precio unitario a texto, esta columna aquí a texto. Después nos despojamos en el punto 99 del lado derecho, que ahora tiene todos los valores de texto. Después volvemos esto a un entero y le agregamos uno. Por lo que podemos ver incluso en casos en los que no estamos tratando con datos de texto, todavía
podemos usar las otras partes de SQL que conocemos y combinar estas operaciones juntas. Entonces podemos ver, por ejemplo, aquí podemos usar algún casting agradable para luego hacer esta operación genial, convirtiendo entre tipo de texto y luego volver a entero. Y luego poder usar también, por ejemplo, las adiciones de enteros aquí. Y por supuesto, dependiendo de tu situación, dependiendo de tus necesidades puedes conseguir con nosotros. También puedes hacer esto dentro de las declaraciones de caso por ejemplo, o también de otros lugares. Por lo que de nuevo, mucho de esto puedes usar para solo procesar tus datos para asegurarte de que puedes obtenerlos en el formato correcto que
necesitabas o para asegurarte de que puedes hacer este tipo de formateo o poder cambiar las cosas alrededor en base a su necesidad. Y por supuesto, porque esto funciona en texto, todavía se
puede lanzar todo en el texto como hemos visto aquí, y poder realizar técnicamente las mismas operaciones en valores que no son inherentemente textos y luego solo ser capaz de volver a convertirlos más tarde si quieres. Por lo que esto puede ser realmente agradable solo para procesamiento
general de datos para asegurarte de que obtienes los datos y el formato real en el que querías tenerlos.
28. 26StringStringPosialmenteInformation 26StringPositionalInformationHB: Ahora en algunos casos, quizá
queramos conocer información adicional sobre los tamaños son componentes de nuestras cuerdas. Entonces echemos un vistazo a estos ahora. Ahora hay diferentes formas en que podemos usar estos, y solo las usaremos ahora mismo para propósito numérico de VR. Pero podemos usarlos uno para el lado analítico para entender con qué tipos de valores estamos tratando. Pero también podemos usarlos para, por ejemplo, cambiarlos en declaraciones de caso para hacer operaciones condicionales específicas. Entonces, solo escribamos primero nuestro esqueleto. Seleccione todo desde pista, limitando nuestros resultados. Aquí cinco. Y lo que quiero hacer es querer entender lo grandes
que se pueden dar algunos nombres a nuestra base de datos actual. Entonces tomemos nuestros nombres aquí. Y quiero saber cuánto tiempo pueden llegar los nombres de axón, porque tal vez hemos asignado un tamaño y queremos saber si el tamaño del gráfico de barras, por ejemplo, hemos asignado a nuestra columna de nombres aquí es apropiado. ¿ Nos estamos acercando a alcanzar el límite superior de ese tamaño de char var es demasiado grande. O tal vez algún otro propósito analítico que queremos conocer la longitud 4. Entonces para hacer eso, podemos usar esta función llamada longitud. Podemos ponerlo dentro del valor que estamos buscando. En este caso, vamos a ver la columna de nombres. Y luego nos vamos a dar un alias como longitud rural, o tal vez podamos llamar a este nombre longitud para que sea aún más descriptivo. Entonces sigamos adelante y ejecutemos esto. Y ahora podemos ver esto nos va a dar cuántos personajes hay dentro de nuestro texto aquí al costado de nuestra cuerda? ¿ Cuántos personajes individuales, incluyendo los espacios, incluyendo los paréntesis, incluyendo cualquier otro carácter especial, cuánto tiempo es en este caso los textos que tenemos? Entonces este es el resultado de que podemos hacer eso. Entonces tal vez ya no queremos esto. Pero lo que no podemos hacer es tal vez queremos encontrar lo más grande, así que queremos verlo por lo menos en orden descendente. Entonces vamos a ordenar por la longitud del nombre en orden descendente. Entonces si ejecutamos esto, podemos ver ahora, de acuerdo, así que el nombre más grande en este caso tiene un 123 caracteres en él. Y podemos ver que tenemos tres sobre un 100. Tenemos unos alrededor de 90 y así sucesivamente. Por lo que se puede ver aquí la escala de las cosas que van. También podemos incluir esto si quisiéramos una declaración de caso. Por lo que podemos decir, recuerda poner comas entre columnas separadas. Caso. Cuando la longitud, basta con mantener este capital de la columna de nombre es mayor a 50. Entonces tomamos el valor 50 plus. Y luego la siguiente declaración que podemos tener, cuando la longitud de la columna de nombre sea mayor a 40. Entonces tomamos el 40 plus, o podemos decir del 41 al 50. Y así no voy a escribir todo esto. En cambio sólo voy a copiarlo varias veces y luego usar alguna sangría. Entonces adelante. Ahora, cuando la longitud sea mayor a 30 y digo 31 a 40, este de aquí va a ser de 21 a 30, éste va a ser de 11 a 20. De lo contrario, vamos a decir menor o igual a 10, terminando nuestra declaración de caso. Y entonces aquí podemos decir esto por ejemplo, Como nombre longitud cubo. Entonces sigamos adelante y ejecutemos esto. Y ahora podemos ver, vale, ahora tenemos una visión aún más rápida de, ya
sabes, en qué categoría, por ejemplo, esto cae. Por lo que podemos ver que también podemos usar esto en diferentes posiciones. Por lo que podemos usarlo ya sea directamente. Pero por supuesto también podemos usarlo dentro de las declaraciones de caso están dentro de otras cosas, sea lo que sea que busquemos. Ahora otra cosa genial que podemos hacer es que podemos encontrar posiciones de personajes si existen dentro de una cadena. Y podemos hacerlo mediante el uso de la declaración de posición. Y luego aquí por ejemplo, podemos decir la subcadena que estamos buscando. Entonces lo que sea que busquemos aquí en el arroyo principal que lo estamos buscando. Entonces, por ejemplo, veamos la primera ocurrencia de la letra a en la columna del compositor. Pero vamos a convertir esto en mayúsculas porque
realmente no queremos diferenciar entre menor y mayúscula a es. Por lo que sólo estamos buscando la primera posición de la letra a en la columna de compositores donde todo se convierte en reyes de cobre. Y entonces podemos guardar esto o darle un alias como posición. Entonces si estás en esto, si hay alguna nueva, Bueno, Si también imprimimos la columna del compositor en el lateral para que en realidad también podamos comparar los resultados. Entonces podemos ver si no hay un interior, entonces nos va a dar posición. Ahora esta posición, empezamos a contar a una aquí. Entonces va a ser 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12. Por lo que podemos ver aquí la primera vez que aparece la IA, está en la posición 12 en nuestra cuerda. En caso de que sea 0, podemos ver que no aparece en absoluto. Y luego en otros casos aquí, por ejemplo, podemos ver que ocurre en la posición 1. Y así sucesivamente. De esa forma, podemos buscar ya sea un valor específico o podemos buscar, por ejemplo, subcadenas. Por ejemplo, podemos buscar a Angus. Siempre que esto aparezca completamente. Ahora para todos estos, va a ser 0 hasta que
encontremos encontremos la instancia donde es Angus Young. Probablemente lo mejor es hacer esto agregando una declaración donde, año, donde compositor. Y yo sólo lo haré, me gusta, aunque lo podamos hacer como minúscula, es más agradable tener como mayúscula para que sea más legible. Es igual. Angus Young estaban usando el ojo así que no necesitamos la capitalización aquí. Yo sólo lo voy a hacer de todos modos, sólo porque se siente un poco natural. Entonces podemos ver aquí, vale, Ahora podemos usar el filtrado solo para hacer alguna comprobación más rápida. Y podemos ver a RA. Entonces la primera vez que vemos angus, la cuerda completa Angus aquí es una. Nunca bien, ya que hemos hecho este filtrado donde no lo ves en ningún otro lugar. Por lo que también podemos buscar otra cosa. Por ejemplo, la primera vez que nos veíamos jóvenes. Y luego otra vez, solo para hacerlo más fácil, filtremos específicamente para todas las filas donde hay jóvenes contenidos dentro. Y de nuevo, estamos usando el ojo así que estamos haciendo filtrado insensible a mayúsculas y minúsculas aquí. Y aquí podemos ver por ejemplo, bien, Entonces la primera posición es siete. Entonces 1, 2, 3, 4, 5, 6, 7. Por lo que la subcadena joven comienza en la posición siete aquí dentro. Y así podemos ver esta función también podemos usar para identificar posiciones de inicio específicas, que pueden volver a ser realmente agradables, como podemos ver aquí, la parte superior también está consiguiendo su uso. Por lo que podemos ver muchas de estas funciones se pueden encadenar juntas, cada una proporcionando una pieza del rompecabezas que luego podemos usar junto con otras funciones para hacer algún procesamiento de datos u otros componentes en nuestras consultas SQL.
29. 27StringSubsetsAndy HB: Muy bien, entonces hemos aprendido mucho sobre cadenas ahora y cómo podemos usar diferentes funciones para obtener información de cadenas que tenemos en nuestras columnas. Pero fluye para seguir adelante y echar un vistazo a algunas cosas más geniales que podemos hacer que específicamente nos ayudarán con el procesamiento de nuestros datos. Entonces sigamos adelante y volvamos a mirar nuestra columna de pista. Y lo primero que quiero mirar es hacer concatenación de cuerdas. Lo que significa que tomamos dos cuerdas o incluso podemos tomar más de dos y podemos unirlas. Entonces por ejemplo, empecemos con unir el nombre y el compositor para que obtengamos una nueva columna que tenga el valor que es el nombre de la canción. Y luego decimos el compositor después. Entonces por ejemplo, eso se vería como para los que están a punto de rock, te
saludamos, y luego después de eso tendríamos el nombre del compositor. Entonces para hacer eso, solo
sigamos adelante y primero escribamos nuestro esqueleto SQL. Y va a ser la mesa de atletismo. Y también solo sigamos adelante y limitemos nuestros resultados a cinco. De acuerdo, entonces vamos a usar el nombre del compositor. Entonces sigamos adelante y solo extrayamos esos, solo para que podamos por supuesto, comparar nuestros resultados. Ahora, lo que queremos hacer es tomar la columna de nombre por ahora. Y a ello, queremos sumar al compositor. Entonces tomemos nuestra columna de nombre. Y ahora a ello, queríamos simplemente agregar en la columna del compositor al final. Entonces la forma en que podemos hacer esta concatenación de cadenas es simplemente
usando estas dobles líneas verticales. Entonces vamos a poner aquí nuestra primera cadena, que en este caso va a hacer referencia al nombre de la columna. Y ahora vamos a poner aquí nuestra segunda cuerda, que en este caso va a hacer referencia al compositor de columnas. Y luego lo que va a hacer, va a tomar lo que
esté aquí y luego al final de ello,
se va a unir a lo que sea que esté aquí. Entonces démosle un nombre a esto. Cortaremos esto, llamaremos a estas columnas concat, bucle concat columnas para columnas concatenadas. Y vamos a seguir adelante y ejecutar esto y ver cómo se ve. De acuerdo, entonces tenemos aquí nuestra columna de nombre inicial. Entonces tenemos a nuestro compositor, y ahora tenemos nuestro resultado aquí, que literalmente es sólo el nombre. Y luego se puede ver en cuanto termine son compositores aquí empiezan. Y también podemos ver que para otras cosas, en caso de que no tengamos valores, el resultado final, como podemos ver aquí, en realidad también va a ser un valor conocido. Ahora por supuesto, el formato que tenemos ahora estos datos no es particularmente útil. Entonces sigamos adelante y que sea un poco más agradable mirar agregando un espacio después del nombre de la columna. Y luego nos despedimos, y luego decimos el nombre del componente. Entonces para hacer eso, sólo
vamos a poner aquí el espacio de cuerdas. Y luego vamos a tener Adiós. Y luego vamos a tener un espacio. Y entonces sólo podemos añadir líneas verticales tumorales. Y de pronto ahora estamos haciendo varias concatenaciones diferentes. En primer lugar estamos tomando la columna de nombre. Entonces hasta el final de eso estamos agregando espacio por espacio. Y entonces estamos haciendo otra concatenación. Eso al final de esto, ahora
estamos agregando la columna del compositor. Entonces si seguimos adelante y
ejecutamos esto, podemos ver ahora, vale, los formatos que mejor tengamos el nombre, entonces tenemos comprar, y entonces tenemos aquí los propios compositores. Ahora podemos hacer aún más aquí. Entonces tomemos esto todo el camino y empecemos con pista. Y luego vamos a poner la identificación del camión. Y luego vamos a dar el nombre de la canción. Y luego le vamos a dar al compositor. Entonces antes de eso, vamos a decir Track. Y entonces ahora queremos tener la pista IT. Entonces, ¿cómo podemos hacer eso? Entonces para hacer eso, Lo que está bien de esto es que en realidad podemos, siempre y cuando estemos entre aquí, también poner en valores enteros. Por lo que podemos simplemente hacer referencia directamente a la columna ID de pista y a la concatenación de cadenas. En realidad sólo nos encargaremos de la conversión. Y para que este formateo sea un poco más bonito, voy a poner un colon y un espacio aquí. Y así si ejecutamos esto, podemos ver aquí ahora tenemos pista y luego tenemos el ID, y ahora tenemos nuestra columna de nombre activada. Entonces sigamos adelante y solo agreguemos otro espacio aquí solo para algo de formato y corremos eso de nuevo. Y así podemos ver a pesar de que nuestro ID de pista es en realidad un entero, que también podemos ver cuando solo lo miramos aquí. El concatenación de cuerdas se encargará de la conversión para nosotros. Pero por supuesto, si no fuera también saber hacer la conversión nosotros mismos usando casting por, por
ejemplo, simplemente lanzándolo a un valor de texto. Entonces en caso de que no se cuidara por nosotros, podríamos ejecutarlo así. Y por supuesto que se encargaría de eso por nosotros. O podríamos lanzarlo a otro tipo de datos que nos parezca más apropiado. Pero como podemos ver, la concatenación de cuerdas. En realidad se encarga de todo esto por nosotros. Ahora, por supuesto, normalmente esto va en la dirección opuesta a donde nos gustaría ir. Por lo general podemos tener datos como este y luego nos gustaría entrar en este formato. Pero sin embargo, sólo ver la concatenación de cuerdas es realmente agradable porque en algún momento sí quieres usarlo y para un buen uso. Y en este caso, nuestras bases de datos muy limpias por supuesto, um, pero en algunos casos puede que tengas momentos en los que tienes, por ejemplo, echemos un vistazo a la columna de la factura. Puede haber momentos en que se tenga la fecha y la hora en dos columnas separadas. Y solo quieres unirlos y usarlos como valor de fecha completa. Entonces podrías hacer concatenación de cadenas para obtener una fecha más hora. Y luego puedes hacer un casting a una datetime por ejemplo. Y luego a partir de ahí tienen directamente la fecha y hora y una columna. Entonces, dependiendo de cómo se formateen tus datos, a veces las columnas que estarías usando no están en el formato ideal en el que realmente te gustaría que estuvieran. O no hay más análisis en la línea o simplemente algún procesamiento que quieras hacer, o simplemente por tener una exportación más limpia al tener menos columnas. Y así la concatenación de cuerdas puede ser realmente agradable porque como
podemos ver, somos capaces de unir diferentes columnas, además de sumar en aduanas. Cuerdas propias están todas unidas. Y por supuesto, observe de nuevo aquí que los textos personalizados que tenemos están dentro de comillas simples. Y cualquier referencia a columnas aquí está entre comillas dobles. Ahora de nuevo, necesitamos las comillas dobles porque al crear tabla, los nombres de las columnas eran para encontrar con comillas dobles. Cuando nuestra tabla no está definida con comillas dobles para usar las columnas, entonces también podríamos simplemente hacer referencia a la columna directamente así. Pero nunca podemos usar comillas dobles para cadenas. Sólo hay reservados para nombres de columna, ya que vimos también son nombres de tabla en este caso, ya que también podemos ver dependiendo de cómo se escribió la sentencia create table. Muy bien, entonces ahora miramos y uniendo las cosas. Vamos en la dirección opuesta y veamos reducir las cosas. Entonces voy a quitarle esto sólo para que ya no tengamos una salida muy larga aquí abajo. Y lo siguiente que vamos a ver es usar o encontrar subcadenas de una cadena que tenemos. Entonces echemos un vistazo a un, justo la implementación más simple primero para encontrar la subcadena. Vamos a ir a usar este método de subcadena, subcadena. Y entonces aquí podemos abrir y cerrar paréntesis. Y entonces lo primero que queremos poner es
el texto o la cadena de la que queremos sacar la subcadena. Por ejemplo, tomemos la columna del compositor. Y luego queremos poner aquí donde queremos empezar. Entonces podemos decir, por ejemplo, desde la posición uno en SQL, la primera posición siempre va a ser la posición uno en caso de que sepas a qué otro lenguaje de programación puedes estar acostumbrado. El primer puesto al que se refiere como posición 0. Pero en SQL, la primera posición es la posición uno. Y si no conoces otro lenguaje de programación, entonces por supuesto esto es muy intuitivo que se haga referencia a
la primera posición como posición uno. Entonces de cualquier manera de uno y el primer personaje aquí va a estar en la posición uno. Y ahora quieres decir cuántos queremos extraer. Entonces para hacer eso queremos decir,
digamos que queremos extraer los primeros cinco. Entonces vamos a decir desde el 145. Entonces lo que esto significa es que vamos a tomar la subcadena. Entonces vamos a tomar una parte más pequeña de la cuerda de lo que sea que se ponga aquí. Y vamos a empezar esto en la posición uno. Y vamos a ir por cinco personajes. Y vamos a darle a esto un alias. Entonces podemos llamar a esta sub columna, y sigamos adelante y ejecutemos esto. Y así podemos ver aquí, empezamos con Angus por ejemplo,
y vamos, Empezamos en la posición 1 de mayo vamos por 1, 2, 3, 4, 5. Ella puede ver aquí. Echemos un vistazo al siguiente. F bola Tez. Por lo que comenzamos en la posición 112345. Y así se puede ver esto también es exactamente lo que tenemos aquí. Ahora en realidad hay otra forma en la que también podemos hacer la sintaxis desde la que realmente no necesitas escribir. Y cuatro también pueden usar comas, una separación en su lugar. Entonces por ejemplo, podrías simplemente ponerte aquí la cuerda y luego podemos poner en una coma. Y este va a ser el punto de partida, y éste va a ser cuántos valores queremos extraer. Entonces si seguimos adelante y ejecutamos esto, podemos ver que obtenemos exactamente el mismo resultado. Y de hecho, en realidad ni siquiera necesitamos el valor final de cuatro. Por lo que el valor final de cuatro ni siquiera es necesario. Y también podemos sacar esto, en cuyo momento simplemente lo haremos. Empieza a tomar toda la cuerda desde apenas la posición inicial. Por lo que podemos ver aquí, en este caso, comenzamos en la posición 1. Entonces nos llevamos todo. Si empezamos en la posición cinco, por ejemplo, entonces sólo vamos a seguir avanzando desde la posición cinco. Entonces 1, 2, 3, 4, 5. Entonces a partir de este personaje, vamos a llevarnos todo como podemos ver aquí. Ahora, incluso en este método, podemos utilizar los resultados de otros métodos que hemos aprendido previamente. Por ejemplo, Tratemos de extraer
los primeros cinco caracteres después de que nos encontramos con el primer espacio. Entonces para ello, en primer lugar, tenemos que encontrar la posición del primer espacio. Y lo podemos hacer usando el método de posición que aprendimos antes. Entonces aquí vamos a encontrar la posición. Y en primer lugar, vamos a poner aquí al compositor. Y queremos encontrar la posición del primer espacio. Y luego vamos a extraer los próximos cinco personajes. Pero como queremos empezar después del primer espacio, en
lugar de en el primer espacio, también
necesitamos agregar uno al resultado aquí. Desde la posición del primer espacio, haremos un inicio exactamente en el espacio. Pero queremos empezar a una después de este espacio. Entonces vamos a sumar uno a aquí. Entonces sigamos adelante y ejecutemos esto. Ahora también esta afirmación podemos hacer más inteligentes mediante el uso de otras funciones que también aprendimos de antemano. Por ejemplo, tratemos de encontrar los primeros cinco caracteres después del primer espacio ese contraencuentro. Entonces para ello, en primer lugar, necesitamos encontrar la posición del primer espacio. Podemos hacerlo usando la función de posición que aprendimos antes. Por lo que podemos decir posición. Y ahora quieres encontrar la posición
del espacio en nuestra columna de compositores y tipo 2. Por lo tanto, recuerda usar la función de posición. Por lo que queremos encontrar la subcadena de la columna del compositor. Y queremos empezar por la posición o más bien después de la posición. Y llegaremos a esto en un segundo después de la posición del primer espacio. Entonces para conseguir el después, esto nos dará la posición del primer espacio. Y así eso significaría que vamos a empezar por ahí. Pero si queremos tomar la posición después del primer espacio, y necesitamos sumar uno a nuestro resultado aquí. Y luego queremos extraer los primeros cinco caracteres. Y así, y esos van a ser los cinco aquí. Y así ahora de nuevo, lo que estamos haciendo es que estamos encontrando estas cuerdas Trump o refinar una subcadena y el color del compositor. Por lo que cada fila va a volver a tener un valor diferente. Y vamos a empezar en la posición del primer espacio más uno. Entonces vamos a empezar uno después del primer espacio, y luego vamos a extraer cinco caracteres. Entonces si ejecutamos esto, podemos ver aquí estos son los resultados que obtenemos. Y vamos a quitarnos nuestra declaración de límites y ver cómo se ve para todo. Específicamente. Para los casos donde no hay espacio como un AC, DC aquí. O veamos si hay otro en este caso aquí. Por lo que se puede ver en estos casos, apenas
estamos empezando por el valor inicial, ya que la posición del espacio y compositor, no
hay espacio. Y así pues esto nos va a dar 0. Entonces si ejecutamos esto por separado y lo guardamos como posición espacial y estamos en la segunda. Para que se pueda ver la posición espacial en este compositor llamado por ejemplo, no
hay espacio, y así esto nos va a dar 0. Y así el más uno como sólo nos va a hacer empezar en el personaje uno, razón por la cual, por ejemplo, vemos aquí empezando así y y por ejemplo, para CDC. También vemos más recién sacados los primeros cinco aquí, que en realidad nos va a dar el nombre completo del compositor por la posición espacial aquí va a ser 0. Y así vamos a empezar en la posición uno, ya que estamos haciendo el plus 1 aquí. Ahora podemos hacer esto aún más complicado si quisiéramos volver a hacerlo, usando los mismos métodos son las mismas funciones que hemos tenido antes. Y Hagamos realmente esto, dividimos esto en varias líneas para no tenerlo ir demasiado lejos en lo horizontal. Entonces lo que vamos a hacer es que vamos a encontrar la primera palabra después del primer espacio. Entonces, por ejemplo, queremos encontrar todo entre el primer y el segundo espacio. Entonces en este caso va a ser joven coma, o aquí va a ser perno tiene coma. Entonces, ¿cómo podemos hacer eso? Bueno, ahora tenemos que hacer este componente aquí inteligente o hay que hacerlo dinámico. Entonces primero lo que queremos hacer es querer encontrar todo después del primer espacio. Y entonces sólo queremos encontrar todo hasta el siguiente espacio. Entonces vamos a empezar con encontrar todo al primer espacio, que en realidad ya hemos hecho aquí. Entonces podemos simplemente tomar esto y podemos copiar esto y poner esto aquí. Pero luego cierran nuestros paréntesis ya que queremos
llevarnos todo después del primer espacio. Ahora, en realidad ya lo hemos hecho porque exactamente esto aquí, esta parte de nuestra consulta aquí se está extrayendo, bueno, en este caso estamos extrayendo los primeros cinco caracteres, pero con la misma facilidad podríamos eliminar esto. Y ahora estamos extrayendo todo después del primer espacio. Entonces queremos tomar eso aunque como insumo. Entonces lo que vamos a hacer es en lugar de usar nuestra columna de compositor aquí, o más bien la cadena correspondiente a la fila actual de la columna de compositor. En su lugar vamos a utilizar el resultado de esto. Y así vamos a sólo aquí, podemos ver eso. Simplemente queremos asegurarnos de que todos nuestros paréntesis estén bien cerrados. Entonces nuestro primer elemento aquí, y volvamos a ajustar nuestro espaciado para que esto sea más legible. Podemos ver que el primer elemento o el primer valor, y aparte aquí está el resultado de esta afirmación. Y esto nos va a dar todo después del primer espacio. Entonces ahora en este caso, por ejemplo, vamos a tener jóvenes y demás, porque no estamos limitando a los personajes. Ahora lo siguiente que queremos hacer es que queremos encontrar todo hasta el siguiente espacio. Entonces porque sabemos que estamos empezando después del primer espacio, Nuestro personaje titular aquí sólo puede ser uno. Ya que estamos empezando directamente después del primer espacio, lo que significa que siempre queremos empezar en la siguiente palabra. Pero ahora necesitamos encontrar la posición final, que va a cambiar en función de la longitud del nombre. Por ejemplo, joven tiene cinco caracteres en el nombre Malthus F6. Y en cada uno de estos casos realmente tenemos una coma detrás. Y así lo lejos que queremos llegar para llegar al segundo espacio va a cambiar de nuevo. Entonces lo que podemos hacer es decir, bien, bueno, ya tenemos esto aquí. Básicamente, sólo queremos subir a la posición del siguiente espacio, sino más bien subiendo a la posición del siguiente espacio y compositor, que va a ser la posición del primer espacio. Tenemos que volver a utilizar aquí el resultado de esta declaración. Entonces poniendo esto aquí y simplemente poniendo esto de nuevo en una nueva línea para que todo sea más fácil de rehacer. De acuerdo, así que sigamos adelante y echemos a correr esto. Y echemos un vistazo a nuestro resultado. Entonces lo que podemos ver es que ahora obtenemos exactamente lo
que queríamos, que es joven una coma biotas y este quiz, es sólo una AMD. Entonces pasemos por esto una vez más porque esta estructura es un poco intrincada. Aquí hay muchos componentes anidados. Entonces nuestro primer valor, la cadena de la que estamos tomando la subcadena, es en realidad el resultado de tomar la subcadena de la columna del compositor comenzando después de la posición del primer espacio, que es lo que hicimos antes. Entonces por ejemplo, para nuestra primera fila aquí, sólo
sería joven y todo después de eso, ya que no estamos limitando lo lejos que vamos. Entonces lo siguiente que hacemos luego usando este resultado es que iniciamos en la posición 1. Desde que ahora, con eso, estamos empezando después del primer espacio. Y queremos subir a la posición del siguiente espacio. Por lo que la posición del siguiente espacio va a ser entonces dos o más bien para conseguir eso adecuadamente, nuevamente
necesitamos usar el resultado aquí. Y de esa manera podemos entonces usar a los jóvenes y demás. Y ahora necesitamos encontrar la posición del siguiente espacio, porque si acabamos de utilizar la columna del compositor original, entonces sólo nos dará la posición del primer espacio en la columna completa. Pero no queremos eso porque ya estamos usando una subcadena parte de esta columna. Entonces queremos asegurarnos de que cuando estamos usando la función de posición aquí, que estamos usando el mismo sustrato. Entonces de nuevo, vamos a encontrar la posición de la primera cadena en el resultado de la declaración de subcadena que hemos escrito aquí arriba, que va a ser la misma que usamos aquí abajo. Ahora en realidad, aquí hay una sutileza, que es que en realidad tenemos un espacio final además de las comas finales que tenemos en algunos casos. Y ahora podríamos tratar de decir básicamente, de acuerdo, vamos a subir a la posición menos uno para deshacernos de los espacios trailing. Pero el problema es en algunos casos cuando ya no hay espacios en nuestra subcadena. Por ejemplo, aquí, nuestro resultado aquí va a ser 0. Entonces vamos a ir ya por 0 longitud, razón por la
cual, por ejemplo aquí AC, DC, no
tenemos nada más cool tomado un no caracteres. Y si ponemos un valor negativo, aquí se
puede ver que en este caso, postgres se está quejando porque no se nos permite poner valores negativos. Aquí podemos sacar cantidades negativas de texto o cantidades negativas de caracteres. Pero ya conocimos la solución o ya
conocemos la función que podemos usar para resolver este problema. A saber, vamos a usar el método trim. Y aquí sólo voy a usar el triunfo correcto porque específicamente queremos recortar el lado derecho. Y lo que queremos hacer es recortar la coma final y también el espacio final. Vamos a terminar nuestra función aquí y simplemente poner esto en la misma línea de nuevo sólo para especie de tener todo y sintaxis. Y sigamos adelante y ejecutemos esto. Y así ahora podemos ver que nos deshicimos de la coma final
así como del espacio posterior que en realidad está oculto. Y si acabamos de tener una coma aquí, son resultados en realidad no cambiarían porque tenemos ese espacio final primero que no podemos ver en este caso por cómo se ve la salida. Entonces sólo ten en cuenta esto, que en este caso tendríamos un espacio de entrenamiento y una coma final. Ahora como ojalá pueda ver, pesar de que algunas de las funciones en los Postgres por sí mismas puedan parecer un poco parecidas. Por ejemplo, ¿por qué necesitaríamos conocer la posición de que no debe haber muchos casos de uso. Pero lo genial es que puedes usar todas estas funciones juntas. Y a través de eso en realidad puedes escribir algunas cosas de procesamiento bastante cool. Y se puede ver aquí podemos especie de nido resultados aquí y usar los resultados de una sub cadena como punto de entrada para otra subcadena. Entonces hay un montón de cosas geniales que podemos hacer encadenando diferentes funciones juntas están usando los resultados para hacer algún procesamiento de datos realmente agradable. Incluso en este caso, si la tarea era sólo sacar el primer valor después del primer espacio y entre,
entre el primer espacio y el segundo espacio más bien. Entonces podemos ver aquí sin embargo, hay otra vez, algunas cosas realmente bonitas que podemos hacer simplemente usando varias de estas diferentes funciones juntas para que podamos conseguir ino, algún procesamiento único y personalizado donde todo es una especie de solo adaptándose a los valores de entrada que tenemos. Y no necesitamos codificar específicamente ninguna longitud específica son puntos de partida o algo por el estilo. Como podemos ver aquí, estos dos valores que hemos devuelto no son longitudes muy diferentes. Pero eso está totalmente bien porque nuestra consulta se encarga de todo y realmente no le importa cuánto tiempo estén cada uno de estos, porque también tiene eso cuidado automáticamente por dentro.
30. 28StringReplacementsHB: Y ya hemos echado un vistazo bastante bueno a un montón de cosas que podemos hacer con cadenas en SQL. Pero hay una cosa más cool y útil que quiero mostrarles, que es reemplazar los valores dentro de las cadenas. Entonces, primero que nada escribamos aquí nuestro código esqueleto. Facilidad tenemos algo. Y en este caso realmente vamos a usar la columna de factura porque quiero usar esta columna de fecha aquí. Por lo que vamos a seleccionar de esta columna de factura. Sólo limitemos nuestros resultados a cinco de nuevo primero. Y lo que quiero hacer, quiero reemplazar este espacio aquí en su lugar por una T. Ahora, hay diferentes maneras en que diferentes programas y tiempos de
escritura ¿hay diferentes maneras en que diferentes personas pueden estar formateando temas? Entonces a veces algo que verás es una T aquí, o verás algunas barras aquí. Ahora, SQL tiene un formato muy específico que quiere, que también puedes ver aquí, año, mes, día con guiones entre ellos. Y tienes el espacio, y luego tienes horas, minutos, segundos. Y luego aquí tienes los componentes de milisegundos. Y se puede ver todo esto es subcampos están separados por dos puntos. Y aquí tenemos un separado por un punto. Y así también podemos mirar en tabla de facturas de honor. Y podemos ver aquí la fecha de factura en este caso es en realidad una marca de tiempo. Pero el valor que vemos como los usuarios se hizo amigable para nosotros. Y en realidad es la mejor representación de este valor de marca de tiempo. Y en realidad también podemos usar este resultado directamente. Pero porque diferentes programas y a veces incluso personas diferentes formatean fechas de manera diferente. Y este es el formato SQL que quieres, pero puede que no siempre lo consigas porque a veces si los datos se acaban
de subir del resultado de una cadena de vacaciones de una marca de tiempo, entonces a veces la forma en que ese programa pone esta marca de tiempo o esta fecha en una cadena y puede que no sea el formato real que necesita. Entonces, solo veamos alguna cadena de colocaciones. A pesar de que ya tenemos el valor que queremos aquí. Usando los reemplazos de cadena, puedes, si el otro formato general es el mismo, ya
puedes obtener algunos valores realmente bonitos. Realmente podemos simplemente ir al formato que necesites. Entonces, ¿hiciste eso? Vamos a cambiar esta fecha de factura aquí para que en su lugar hábito mayúscula T entre aquí, que son lo común que podrías ver en algún momento. Entonces para hacer eso, vamos a seleccionar fecha de
factura y vamos a seleccionarla para que tengamos que comparar con. Y ahora para hacer la colocación real, vamos a usar la función Reemplazar. Y mantengamos esto en mayúsculas. Y la sintaxis que queremos usar aquí es primero, queremos poner la cadena completa que vamos a usar, que en este caso sólo va a ser con el resultado de la fecha de factura, después queremos tener el valor que queremos reemplazar. Entonces por ejemplo, en este caso, y vamos a reemplazar el espacio. Y entonces tenemos el valor por el que queremos reemplazarlo. Entonces por ejemplo, vamos a reemplazarlo por la T. mayúscula Y entonces vamos a darle a esto un alias a como fecha modificada. Ahora en realidad hay una sutileza más de la que necesitamos cuidar,
que es nuestra fecha de factura es una marca de tiempo internamente. Pero cuando lo estamos viendo,
en realidad se convierte para nosotros en la representación textual de esta marca de tiempo, que por supuesto hace que sea mucho más fácil de leer. Es mucho más fácil leer la fecha real con año, mes, día, horas, minutos, segundos, en lugar de mirar sólo un montón de números que representan un tiempo. Entonces lo que necesitamos hacer para hacer esto correctamente es que también necesitamos convertir esta marca de tiempo a un formato de texto. Y sigamos adelante y hagamos la conversión aquí. Y también sigamos adelante y hagamos la conversión internamente. En realidad, no hagamos eso aquí porque quiero mostrarles el resultado de sus dos, pero necesitamos tenerlo aquí porque de lo contrario estamos viendo estos,
estos en realidad son valores con marca de tiempo. Entonces hay sellos de tiempo, pero necesitamos convertirlos en una representación de texto de una marca de tiempo, que cuando lo haces en SQL, se ve así. De lo contrario no podremos usarlo correctamente. Entonces si seguimos adelante y ejecutamos esto, podemos ver aquí que este es el resultado que estamos obteniendo cuando lo estamos convirtiendo al formato de texto, que es básicamente todo después del punto aquí, que en este caso no se usa solo porque no está presente. Y entonces tenemos el espacio aquí sustituido por el té. Entonces podemos ver que este es el SQL o presentación que vemos cuando tenemos valores de marca de tiempo, pero no hacemos ninguna otra conversión. Es así como se muestran al usuario en este caso. Y en realidad lo haríamos, si queremos echar esto a un texto, podemos ver aquí este es el casting resultante que tenemos que son exactamente
el mismo valor porque aquí no tenemos ningún componente de milisegundos extra. Pero sigue siendo agradable solo estar al tanto de esta sutil diferencia que vas a obtener al convertir a una columna de marca de tiempo en un tipo de datos de texto. Sólo porque cambia ligeramente cómo se ve la salida, pero eso también afecta realmente cómo vamos a usar estos valores. Por lo que podemos ver a veces podemos obtener fechas, fecha o valores de fecha y hora los cuales tienen este equipo entre, que en este caso, realidad
podemos encadenar. Y vamos a encadenar. Porque en realidad, sólo tratemos el ejemplo de que estamos consiguiendo este valor dentro. Entonces vamos a encadenar nuestras operaciones aquí. Pero en realidad, simplemente tomamos
esta columna de fecha modificada y luego vamos a quitar esta básica AND, O esta t otra vez. Entonces vamos a sustituir del resultado de esta declaración de reemplazo aquí, que es lo que aquí vemos. Entonces si esto fuera una verdadera entrada y queremos quitarle el té, ya que ese tipo de lo pone en el formato esco que necesitamos usarlo como ID, fecha, hora, o como marca de tiempo. Entonces vamos a reemplazar esto y vamos a reemplazar lejos. Y pongamos esto en una nueva línea por ahora. Vamos a reemplazar la T y vamos a
reemplazarla por un espacio y el interminable. Y también es dar el nombre de la columna aquí otra vez. Entonces si seguimos adelante y ejecutamos esto, podemos ver que estamos recuperando el valor exacto. Pero de nuevo, lo que hemos hecho es que hemos sustituido el espacio aquí por la t. Y luego hemos sustituido a ese despertar T. Y a veces solo verás que, ya sabes, puede
haber casos en los que solo tienes horarios de citas que se ven así. Ahora existen algunas bases de datos SQL que pueden lidiar con este formato. Por ejemplo, postgres es uno de ellos donde en realidad todavía podemos tomar esto y convertirlo a un tipo de marca de tiempo. Y podemos ver si ejecutamos esto, corremos, todo este asunto. Podemos ver aquí que estamos especie de convertirlo de nuevo a marca de tiempo. Pero en general la fórmula SQL correcta que desea como un espacio entre aquí, porque no todas las bases de datos SQL pueden lidiar con estos valores T como este. Y así en algunos casos, la declaración en realidad puede chocar. Y así que solo ten en cuenta que hay una especie del SQL ideal para siempre sin que quieras, que es año, mes, día,
espacio, horas, minutos de colon, segundos de colon. Y la razón por la que lo estás teniendo así es porque aunque estos valores sean cadenas, si los ordenas, todavía se van a ordenar en el orden correcto. Y por eso también es importante que tengamos este formato de año, mes, día y día NADH, mes, año o mes día, año o algo así. Tener este formato muy específico hace que todo sea muy estándar. Entonces en este caso, podemos ver en Postgres, la T mayúscula no es un problema, pero esto no es cierto para todas las bases de datos. Y SQL es una especie de muy variable. Y por supuesto, si terminas teniendo que ponerte, tal vez uses varias bases de datos SQL diferentes. El comunicado puede hacer más de uno de ellos y puede chocar y el otro porque de nuevo, se
acercaron a eso fue ligeramente diferente. Entonces sólo ten en cuenta eso. Idealmente, quieres ir por este formato limpio. Y por supuesto, se pueden utilizar todos los reemplazos y fundidos. Y esto fueron subcadenas y todo lo demás que hemos aprendido, todo el material de procesamiento para especie de modificar todas las columnas y ponerlas en el formato adecuado para que puedas hacer la conversión de tipo. Pero solo ten en cuenta que puede encontrarse a veces teniendo columnas de fecha y formatos incorrectos. Y otra que comúnmente se ve es, por ejemplo, tener guiones, listones en lugar de guiones. Entonces otra no tan comúnmente vista es,
um, empezar a convertir esto en una marca de tiempo para que realmente podamos ver el resultado. Pero otro que comúnmente se ve como tarareando como guiones aquí o algo así. Entonces solo ten en cuenta que estas son cosas que puedes encontrar. Y este caso, como podemos ver, porque el casting de marca de tiempo volvió a funcionar, pero otras bases de datos SQL pueden no ser tan grandes para adaptarse a estos diferentes formatos. Entonces solo ten en cuenta que podemos usar los métodos de reemplazo simples así como otros métodos de cadena que utilizamos para procesar o manipular datos de antemano para conseguir nuestros datos en el formato adecuado.
31. 29DateAndTimeHB: Ahora una información de fecha y hora como también tenemos aquí en la columna de fecha de factura es probable que aparezca una forma u otra muy a menudo en tus tablas SQL porque es realmente agradable hacer un seguimiento de cuándo ocurrieron las cosas. Entonces solo echemos un vistazo a las fechas y horarios y cómo podemos usarlos para extraer algo de información de ellos. Sólo porque va a ser un campo tan común ver. Ahora lo que es realmente bonito es que SQL es realmente bueno para tratar con información de fechas y hora. Y, y eso es genial porque nos da mucha flexibilidad. Entonces, solo sigamos adelante y primero escribamos una declaración de selección esqueleto de nuestra tabla de facturas, limitando nuestros resultados 25. Y de nuevo, ya vimos esto antes, pero solo sigamos adelante y seleccionemos la columna de fecha de factura. Y vamos a seguir adelante y ejecutar esto. Y podemos ver aquí esto es una especie de los textos o presentación que no podemos volver a nosotros en nuestra mesa porque el valor en sí tiene una marca de tiempo. Y también vimos que si echamos esto a un valor de texto, simplemente
podemos conseguirlo sin el componente de milisegundos en este caso porque en realidad no está incluido. Pero digamos que sólo estamos interesados en usar la fecha, por ejemplo, no estamos particularmente interesados en usar el tiempo. Digamos que queremos hacer un análisis donde queremos ver, vale, necesito entender cuando las cosas pasan día a día solo, o tal vez ni siquiera ese tamaño. Pero no estoy súper interesado en el componente de tiempo aquí. Entonces lo que podemos hacer es usar nuestra fecha de factura. Podemos simplemente lanzar esto a una fecha. Entonces sigamos adelante y tal vez vamos a darle a esto un alias como fecha. Entonces podemos ejecutar esto y podemos ver aquí, esto va a ser sólo nuestro tipo de salida inicial. Y si solo sacamos el componente de fecha, podemos ver que muy fácilmente acabamos de cortar la fecha y podemos hacer cosas con la fecha. Y también podemos, por ejemplo, sacar el tiempo. Porque tal vez, digamos, tal vez digamos que sólo estamos interesados en hacer un análisis mirando la hora específica de los días. Y no estamos súper interesados en los días y la fecha aquí, sino más bien estamos más interesados en mirar la hora del día porque queríamos entender las fluctuaciones con la hora del día o algo así. Por lo que podemos ver aquí tan pronto como lo tengamos en el formato de marca de tiempo adecuado o en el formato de fecha y hora adecuado. Podemos entonces muy fácilmente simplemente extraer de ella la información que necesitamos. Y también podemos usar esto para filtrar. Entonces, por ejemplo, vamos a quitarnos primero
nuestra declaración de límite para que como que obtengamos el resultado completo. Digamos que estamos interesados en analizar algún comportamiento basado en la hora del día de la semana. Eso es entre, que comienza desde la primera de la primera línea 2000 y va hasta la sexta de la primera. Entonces podemos hacer es en nuestra cláusula donde, podemos decir donde la fecha de factura está entre. Y aquí podemos decir, vamos a tomar la cuerda 2019, uh, 11. Esto podemos echar a una fecha y fin. No hace falta estos paréntesis aquí entre esto. Y luego también aquí, lo que vamos a tener este 2000 y que yo quería escribir nueve aquí ahora 192 mil línea y luego un 1 y 0, 6. Y de nuevo, vamos a convertir esto en una cita. Entonces si seguimos adelante y
ejecutamos esto, podemos ver aquí muy fácilmente, podemos hacer filtrado de fechas y también podemos hacer día específico durante. Porque SQL entiende intrínsecamente los formatos de fecha y hora, que por supuesto es realmente útil porque los valores de fecha y hora surgen con tanta frecuencia. Y más recientemente, o más en general, te importa lo que pasó más recientemente, no tanto como lo ocurrido cinco años En el pasado, por
supuesto, quizá quieras poder acceder a esa información. Pero la mayoría de las veces cuando estás tratando de acceder a información o hacer un análisis, estás más interesado en los datos más recientes. Y así con SQL, podemos hacer esto muy fácilmente simplemente usando los valores de fecha inherentes,
los valores de tiempo inherentes, así
como el valor de marca de tiempo, ya que todos son tipo de compatibles entre sí. Ahora, también hay otra cosa genial, que es esta función llamada ahora. Ahora lo que eso hace es básicamente que da el valor actual de fecha y hora. Entonces sigamos adelante y ejecutemos esto. Y podemos ver aquí el resultado aquí va a ser el mismo porque sólo devuelve un valor, pero da la fecha y hora actuales en hora UTC. Por lo que podemos ver que da el valor exacto de fecha y hora en hora UTC. Y también podemos usar esto de nuevo aquí para extraer valores de ella. Por ejemplo, para obtener la fecha actual, solo
podemos hacer de vez en cuando usar el resultado. Y de aquí solo extraiga la fecha. Y podemos guardar esto como fecha actual. Y así nuestra columna de fecha actual aquí, por ejemplo, sólo va a ser lo que vemos aquí, la fecha actual. Ahora también podemos usar esto para filtro. Por ejemplo, podemos decir, está bien, vamos a encontrar todos los lugares donde la fecha de factura sea mayor o igual a o pista. En este caso, tendrá más sentido. Pero digamos o el componente devs de la fecha de factura es igual a la fecha de hoy, que podemos hacer esto. Ahora en este caso, no vamos a conseguir que nos devuelvan ningún valor, por supuesto, porque los datos aquí son viejos y no
hay nada que ese tipo de se acerque a la fecha de hoy como podemos ver. Pero aún podemos usar un filtrado dinámico así. Interés tipo de tener nuestras consultas se adaptan en base a la fecha y a medida que cambian las cosas, nuestros datos aún se van a mantener actualizados porque estamos usando esta función interna NOW, que simplemente nos da la fecha y hora actuales. Y luego podemos extraer, por ejemplo, la fecha y, ya sabes, obtener información de fecha a partir de ahí. Y por supuesto, porque SQL
entiende intrínsecamente y hace un uso adecuado de los valores de fecha y hora, podemos hacer todo tipo de comparaciones y mirar rangos y todo tipo de cosas geniales.
32. 30DateTimeIntervalsHB: No además de solo poder extraer
valores de fecha y hora y poder hacer comparaciones y cosas. Sql también tiene una opción realmente genial de que podamos usar intervalos de tiempo. Entonces echemos un vistazo a eso. Vamos a ejecutar aquí nuestro esqueleto select, seleccione de nuestra tabla de facturas, limitando nuestros resultados a cinco. Adelante y corre esto. Ahora, intentemos seleccionar o mejor dicho intentemos encontrar primero la diferencia horaria entre la fecha actual de hoy y la fecha de la factura aquí. Entonces vamos a extraer la fecha de la factura para que tengamos valor de comparación. Y luego vamos a usar nuestro ahora para darnos la corriente en fecha y hora. Y ahora para conseguir un intervalo, todo lo que tenemos que hacer es restar la fecha de la factura, que tiene una marca de tiempo. Entonces debido a que ambos son compatibles con marca de tiempo, ahora
podemos tomar nuestro valor nulo, lo que nos da también una marca de tiempo y restar de la fecha de la factura. Y aquí podemos llamar a esto, por ejemplo, como tiempo desde la factura. Y si ejecutamos esto, podemos ver aquí esta es nuestra fecha de factura y este año es la diferencia horaria desde la voz. Entonces por ejemplo, hemos visto aquí, estamos viendo en este caso, alrededor de 4,200 días desde que estas facturas transcurren medio dependiendo de la fecha exacta. Ahora también podemos convertir estos, por ejemplo, a valores de fecha porque actualmente estamos obteniendo información sobre horas, minutos y segundos. También podemos convertir estos a la fecha. Entonces si queremos y en qué caso sólo vamos a conseguir directamente fechas, oscuro di, diferencias, como podemos ver aquí. Entonces esta es una forma en que aparece ese tipo de intervalo. Podemos obtener diferencias de intervalo entre diferentes tiempos. Pero claro que no se detiene ahí. También podemos usar intervalos. Entonces echemos un vistazo a eso. Primero que nada tomemos nuestra columna de factura y nuestra columna de fecha de factura, y solo agreguemos algo de tiempo en ella. Entonces bebé, no queremos tener o no queremos mostrar los datos en UTC. No hemos almacenado internamente en UTC, pero cuando lo
sacamos, queremos cambiar a una zona horaria separada. Por ejemplo, vamos a UTC más 1. Entonces, ¿cómo podemos agregar una hora en fecha de factura del tour aquí? Bueno, en realidad es realmente fácil porque todo lo que tenemos que hacer es hacer plus aquí. Y ahora tenemos esta opción de intervalo y SQL. Y el intervalo. Ahora solo ponemos aquí una cadena de la cantidad de tiempo que queremos sumar. Por ejemplo, queremos sumar en una hora. Y aquí podemos guardar esto ya que, por ejemplo, sumar una hora. Entonces si ejecutamos esto y vamos a quitarnos esto por ahora, viene un poco en el camino. Entonces si ejecutamos esto, podemos ver que este es nuestro estado de entrada original y esta es nuestra fecha de factura con una nuestra auditoría sobre él. Entonces lo que es bueno es que si tenemos nuestros valores de fecha y hora internamente, como puedes ver, todavía podemos hacer todo tipo de conversiones de línea de tiempo. Y una vez que lo sacamos y lo hacemos apropiado a lo que queramos mostrar,por
supuesto son opciones mucho solo para sumar en una hora,
pero realmente no podemos hacer por
supuesto son opciones mucho solo para sumar en una hora, todo lo que nos gustaría, por
ejemplo, más bien vamos a renombrar primero nuestra columna. Por lo que aquí podemos decir sumar tiempo. Añadamos 1. Segundo, tendencia. Hazlo así. Puedes hacer esto y pensar por un minuto. Podemos sumar en un mes, podemos sumar en un año, o podemos igualar en varios años. Si quieres sumar un múltiplo años, puedes hacer dos años o también puedes poner una S aquí como podemos ver, sus resultados por sí mismos no cambian. Pero es agradable porque podemos usar este valor de intervalo ahora para tener un intervalo de tiempo que especificamos a través de la cadena aquí. Ahora lo que también podemos hacer, por ejemplo, digamos que queremos agregarlos dos años y un mes. Ejecuta esto. Y podemos ver que todo adopta a dos. Entonces la declaración de intervalo aquí es genial. Y es genial poder usarlo en la declaración selecta, pero es incluso más fresco poder usarlo dentro de nuestro filtrado. Entonces echemos un vistazo a eso y vamos a seleccionar o vamos a quitar o a declarar. Y vamos a deshacernos de nuestro límite por ahora. Y también solo deshacernos del esto aquí y que sea por lo que vamos a filtrar. Por lo que quiero sumar en 15 años a nuestra fecha de factura. Y ahora quiero filtrar por donde nuestra fecha de factura más el intervalo de todos. Hagámosnos a todos capital solo para especie de indicar de nuevo, esa es declaración SQL. Más el intervalo de 15 Años es mayor a la fecha y hora actuales. Entonces si ejecutamos esto, podemos ver en este caso vamos a conseguir que se devuelvan todos los valores porque si sumamos un 15 años a la fecha de factura que vamos a estar en 2024. Y así podemos ver, por supuesto, en este caso todo va a estar más allá de la fecha y hora actuales. Ahora esa es una forma de hacerlo. Otra forma de hacerlo, o de hacer filtrado es, digamos que queríamos encontrar todas las facturas en la última semana. Entonces lo que podemos hacer aquí es que también podemos usar intervalos del otro lado. Entonces digamos nuestro primero de todo, tomemos esta manera sólo para usar un poco las columnas como las encontraríamos en tablas regulares. Entonces digamos que aún se está actualizando nuestra tabla de fechas de factura y queremos encontrar todas
las facturas dentro de la última semana para que podamos escuchar decir bien. Tomemos la fecha y hora actuales y restemos el intervalo de siete días. Por lo que estamos buscando todo dentro de los últimos siete días. Y así podemos ejecutar esto. En este caso, no vamos a conseguir nada devuelto porque esto sucedió hace siempre. Entonces podemos hacer aquí, por ejemplo, como podemos otra vez. En este caso, nuestros resultados son por supuesto que no va a cambiar de ruteo consiguió tantos años. Pero puedes ver aquí solo imaginando que nuestra fecha de factura se actualizó continuamente. Podemos tener nuestras consultas adaptándose a los intervalos de tiempo actuales, o podemos encontrar rangos de tiempo específicos ya sea tomando la fecha y hora actuales, despegando siete días. Podemos lanzar esto a una fecha para asegurarnos que la información de tiempo no entre y luego despegar siete días. Y de esa manera, podemos hacer algún filtrado realmente bonito para mirar, por ejemplo, las cosas que suceden
los últimos siete días y las cosas que sucedieron los últimos 10 días, que las cosas que sucedieron en las últimas 24 horas, las cosas que ocurrió en las últimas cinco horas. Podemos tener unos intervalos de tiempo realmente personalizados para usar para filtrar. Y eso es realmente bonito porque la mayoría de las veces cuando estamos usando datos que tienen algún tipo de marca de tiempo adjunta a ella. No vamos a estar usando todos los datos a lo largo de todo el tiempo. La mayor parte de ella, la mayoría de las veces sólo nos interesa mirar regiones de tiempo específicas. Y así podemos ver teniendo esta opción para poder usar intervalos
para hacer comparaciones con la fecha y hora actuales o con la fecha actual,
o definir intervalos de tiempo mediante el uso de esta declaración de intervalo aquí, podemos hacer realmente declaraciones selectas personalizadas que solo nos dan datos para exactamente los plazos que nos interesan.
33. 31CommentsHB: Ahora otra cosa muy importante de escribir consultas, o también de escribir código en general es dejar comentarios. Porque cuando estás leyendo algo y si se vuelve complejo, Es realmente agradable tener comentarios o anotaciones que
expliquen lo que estás haciendo o lo que estás pensando o lo que esta parte es cuatro, que cuando vuelvas a ella más tarde o cuando otras personas trataron de leerlo, entienden el proceso de pensamiento y lo que está pasando aquí. Porque a veces si escribes una consulta más compleja o código más complejo, y luego solo la dejas por un par de meses y luego intentas volver cuando intentas
averiguar qué hiciste exactamente en cada punto y por qué esto es aquí en Ohio, tiene este formato y por qué tal vez hiciste el truco especial. Haber dejado un comentario es una manera realmente bonita de
guiar a las personas a través de él para que puedan entender tu proceso de pensamiento, la forma de pensar y por qué, por ejemplo, específico que se ha hecho o cualquier otra cosa que quieras escribir dentro. Entonces echemos un vistazo a cómo podemos escribir comentarios. Y sólo vamos a utilizar una simple declaración de consulta aquí de nuestra tabla de facturas. Y sólo limitando nuestros resultados a cinco, sólo un poco porque es una declaración de esqueleto facial tener. Entonces sigamos adelante y dejemos algunos comentarios. Dejar algunos comentarios muy básicos se convierte en el no obstante. Entonces la primera forma en que podemos dejar comentarios es usando un doble guión. Y entonces todo lo que escribimos después de este guión aquí va a ser común. Bien. Ponga aquí un espacio para que se vuelva más legible. Por ejemplo, aquí podemos decir seleccionar columnas. Y si ejecutamos esto, entonces se puede ver que como que nos devuelven todo. Y aunque quitemos el espacio aquí, sigue siendo todo funciona. Los comentarios no forman parte de la ejecución, pero podemos dejarlos aquí. Podemos ver que estos no se extienden a las siguientes líneas como podemos ver porque esta parte de la sentencia SQL todavía se está escribiendo. No obstante, si no hubiéramos separado o sentencia SQL sobre varias líneas, entonces todo después de esto en la misma línea va a ser comentado, en cuyo caso ahora vamos a tener un problema. Entonces eso también, es agradable tener todas las cosas divididas en varias líneas. Ahora en este caso, como habrás visto, Databricks realmente hace algunos comentarios inteligentes, donde si tienes un comentario y añades una nueva línea en algún lugar, automáticamente agrega este guión numérica al frente,
que en la mayoría de los casos en realidad realmente agradable en este caso cuando estábamos tratando de volver a nuestra consulta y por supuesto no era lo que estábamos tratando de hacer. Eso Eso es algo que es específico del agarre de datos y no específico de Postgres. De todos modos, podemos usar declaraciones comunes como esta. Y acabemos de ejecutar esto otra vez para deshacernos de la advertencia. Por lo que podemos usar declaraciones KMS como esta para anotar nuestro código o nuestras consultas. Por lo que podemos sentarnos aquí, por ejemplo, seleccionando desde la tabla de facturas. Por supuesto, en este caso, nuestros comentarios son algo triviales y no particularmente útiles. Pero a medida que el proceso de pensamiento se hace girar, tal vez dejas un comentario al inicio de una parte más compleja de la consulta. Y luego se puede ver que esta parte hace esto. No necesitas anotar cada línea,
pero solo decir como este siguiente bloque es responsable esto o cuando tienes una lógica específica en algún lugar ahí, estamos usando, por ejemplo, declaraciones de posición para encontrar específicos intervalos. Se puede decir que el formato de datos R es así, razón por la
cual podemos usar el supuesto para encontrar la posición de esto, para encontrar este siguiente valor. Ya sabes, solo explicando tu proceso de pensamiento de eso cuando la gente viene a verlo o a renovar, vuelve a ello un par de meses después porque tal vez no has necesitado cambiar en que
todavía puedes entender el proceso de pensamiento y no es necesario tratar de descomponer las consultas y
entender y especie de recapitular el proceso de pensamiento que se te ocurrió hace un par de meses. Entonces sí, podemos escribir una sola línea surge esto, también
podemos escribirlos en líneas separadas. Por ejemplo, nuevo comentario de línea. Entonces esto va a ser un comentario que está ocurriendo en una nueva línea. Y de nuevo, todos estos comentarios que comienzan con S doble guión solo abarcan líneas simples. También podemos tener continentes multilínea. Ahora, una forma que hemos visto como que podemos hacer es simplemente extendernos y commons a múltiples líneas y tener más líneas aquí. Pero esto no es muy eficiente. Porque si quieres escribir sobre varias líneas, no
quieres tener todos estos guiones ahí dentro. Entonces lo que podemos hacer en su lugar es que podemos usar un formato que se vea como estrella de corte hacia delante. Y entonces eso inicia el comentario multilínea. Y podemos terminar el comentario con estrella hacia delante otra vez. Y luego simplemente quitando las declaraciones aquí porque ya no menos de lo necesario. Y ahora podemos ver ahora tenemos un comentario multilínea. Por lo que todo entre esta estrella de corte hacia adelante y estrella hacia adelante, todo esto va a ser comentado y pedir comentarios vayan. Podemos ver que si ejecutamos esto, nuestros resultados por supuesto no van a cambiar. Ahora con esto, bueno, incluso podemos hacer es que podemos poco común entre las declaraciones. Por ejemplo, podemos decir aquí a punto de decir la tabla y luego terminando o común de nuevo. Y podemos ejecutar esto, y esto todavía va a funcionar porque nada de esto va a ser parte de la consulta final real que se va a ejecutar. Todos los comentarios que aliviando aquí son solo para hacer nuestras consultas o si lo estás usando en otro lugar. Y el código son los comentarios en general están ahí para hacer el código más legible, para explicar tu proceso de pensamiento, para explicar la lógica. Nuevamente, el punto de los comentarios es no comentar cada línea, sobre todo como el común trivial que se han comprometido aquí seleccionando nuestras columnas, seleccionando de la tabla de facturas. Pero más bien es si vas a entrar en una parte que no es obvia y autoexplicativa que puede causar cierta confusión. Es bueno simplemente dejar un comentario para explicar en este común puede ser más corto, puede ser largo dependiendo de cuánta explicación sea necesaria sólo para explicar lo que está pasando aquí. Entonces eso es alguien que puede ser nuevo en ello, que ve la consulta por primera vez. ¿ Estás regresando un mes, dos meses, seis meses, un año después a la misma consulta todavía se puede entender muy rápidamente y tipo de entender la esencia de la consulta. Entender lo que está pasando en cada parte y que no están
pasando por ella y o perdidos por lo que está pasando en una parte específica. Y luego tienen que pasar tiempo tratando de averiguarlo, vale, entonces ¿qué es exactamente esta parte de la consulta haciendo aquí y por qué es así y como por qué hay todas estas condiciones especiales? Entonces de esa manera, Mino, tener comentarios puede hacer mucho más fácil la vida de todos.
34. 32AggregaciónFuncionesHB: Ahora lo que realmente es genial de SQL es que las consultas pueden ir mucho más allá de solo seleccionar columnas y filas específicas y hacer operaciones en filas, lo cual ya es muy genial. Pero también tenemos opciones para hacer todo tipo de agregaciones. Entonces echemos un vistazo a algo de esto ahora. Volvamos a entrar en nuestra tabla de temas. Y veamos específicamente esta columna de milisegundos y solo mírelos, intentemos obtener algo de información agregada sobre esto. Por ejemplo, y si queremos encontrar el tiempo promedio de un sólido o el tiempo más largo o el más corto. ¿ O qué pasa si solo queremos alguna información como cuántos valores hay en esta columna? Entonces echemos un vistazo a algunos de estos. Vamos a escribir primero nuestro esqueleto select, seleccionando de la mesa de camiones y limitando nuestros resultados a 5 más sólo un poco nos vemos, esta es la tabla para que me gusta seleccionar de. Muy bien, así que vamos a ahora primero tratar de encontrar los milisegundos promedio a paciente. Entonces para hacer eso, podemos usar una función llamada o denotada AVG para promedio. Y si aquí sólo ponemos dentro de la columna de milisegundos, entonces vamos a obtener un valor devuelto, que va a ser la duración promedio. Sabemos que es la duración porque eso es un poco lo que dona la columna de milisegundos. Pero es sólo el promedio de la columna de milisegundos. Por lo que podemos darnos un mejor alias promedio de milli segundos. Y así este va a ser el valor promedio de nuestra columna de milisegundos. También podemos hacer otras cosas. Por ejemplo, podemos encontrar el tiempo más largo. Por lo que podemos encontrar el máximo de la columna de milisegundos, que podemos ver aquí. Este aquí va a ser el tiempo más largo que tengamos en esta columna de milisegundos aquí. Y este es nuestro valor aquí. También podemos encontrar el tiempo más corto tomando el mínimo. Suma, actualizando de nuevo nuestro nombre aquí vamos a tener el mínimo. Y aquí podemos ver este es el tiempo más corto que tenemos en nuestros valores de camión para el tiempo en milisegundos. También podemos usar una, otra función de agregación donde podemos resumir todos los valores de una columna, por ejemplo. Entonces podemos resumir todo en los milisegundos, que va a ser el tiempo total de todas las pistas. Por lo que resumir todos los valores en esta columna de milisegundos aquí nos va a dar este resultado aquí como podemos ver, ahora, hay otra función genial que tenemos, que es el conteo. Ahora el recuento aquí dentro, vamos a poner una columna y se va a contar el número de ocurrencias que tenemos. Por lo que sólo nos va a dar un recuento del número de valores que tenemos. Entonces, por ejemplo, podemos poner aquí la columna de milisegundos. Y nos va a decir el número de instancias en milisegundos. Y si ejecutamos esto, podemos ver en este caso tenemos 3 mil 503 instancias diferentes. Por lo que 3,503 valores aquí. Estos no son valores únicos. Estas son solo instancias diferentes en este caso, o la mesa fue un poco cortada en 500 solo porque no quiere mostrar demasiado. Pero en realidad podemos, en realidad podemos ver aquí para ti en ellos filtrando por ejemplo, tenemos más valores disponibles. De hecho, tenemos 3,503 filas donde estos valores a encontrar. Ahora la razón por la que específicamente digo el número de instancias en milisegundos y porque cuando hay valores nulos, esto afecta el conteo. Entonces echemos un vistazo a algún valor es donde sabemos que no hay valores, que es la columna del compositor. Entonces contemos el número de instancias que tenemos y la esperanza y la columna de compositor como número de instancias y compositor y ejecutemos esto y mirando los resultados aquí vemos tenemos 2525 filas que no contienen valores nulos. tanto que para los milisegundos, tenemos 3,503 filas que no contienen valores nulos. ¿ Qué pasa si solo queremos obtener el número total de filas sin tener que preocuparse por si una columna puede o no suceder, sin valor dentro. Bueno. Y dos formas comunes de hacer eso. Uno de ellos es sólo poner una estrella aquí dentro. Esto va a ser número total de filas y el inicio sólo va a básicamente sólo nos va a dejar contar todo. Entonces podemos ver aquí, si lo miramos, tenemos 3,503 filas sin unos valores antiguos. También podríamos poner el entero aquí, y solo va a contar uno por cada fila que tenga. Y así podemos ver que vamos a obtener el mismo resultado devuelto aquí. Por lo que podemos usar la función de recuento
en columnas, en cuyo caso vamos a contar el número de filas donde tenemos unos valores desconocidos, los cuales podemos ver son diferentes dependiendo de las diferentes columnas. Por ejemplo, en el compositor, donde sí tenemos valores nulos, este número es menor. O podemos poner ya sea una estrella o el número de uno dentro de aquí. Y eso sólo va a contar para nosotros el número total de filas que tenemos, como podemos ver aquí. Ahora podemos, por supuesto, todavía hacer un montón de otras cosas geniales también, o columnas. Por ejemplo, primero usemos algunas aritméticas simples y volvamos o milisegundos en dos minutos, minutos fraccionarios. Entonces lo primero que vamos a hacer es sólo dividir o milisegundos por mil. Eso nos va a dar al Sung de segundos. Y luego lo vamos a dividir por 60, lo que nos va a dar la duración de la canción en minutos. Entonces sigamos adelante y ejecutemos esto. Y si nos desplazamos hacia la izquierda, podemos ver aquí la longitud media de la canción en azul. Este caso va a ser minutos, es poco más de seis minutos. Entonces 6.05, que es 606, que ahora no son seis minutos y segundos. Pero este valor aquí va entre 01. Por lo que es 0.6 de uno. Entonces esta va a ser fracción que está aquí. Entonces podemos ver, todavía podemos hacer cosas a nuestras columnas dentro y luego usar las agregaciones en ella. Y claro que sólo vamos a estar llamando la función sobre el resultado final que tenemos aquí dentro.
35. 333Agrupación y 33GroupingAndFilteringAggregationsHB: Por lo que acabamos de ver las agregaciones y agregaciones son geniales. Pero lo que es incluso más fresco como agregaciones por diferentes grupos. Entonces lo que eso significa es, digamos que queremos averiguar el número de canciones que cada uno de los compositores que escribieron. Actualmente, lo que tendríamos que hacer es poder usar la función de recuento, cual podemos contar el número de filas que tenemos. Y luego vamos a tener que filtrar por cada compositor, por cada compositor diferente. Pero SQL en realidad puede ir mucho más allá de eso. Y lo que podemos hacer es crear agrupaciones por cada entrada diferente que tenemos aquí. Y luego podemos obtener agregaciones para cada una de estas diferentes entradas que tenemos. Ahora esto va a ser específico para usar agregaciones y hay algunos requisitos específicos, pero echemos un vistazo a eso. Hagamos la primera tarea de la que no se puede hablar, que es seleccionar para encontrar el número de pistas que tenemos para cada compositor diferente aquí. Entonces comenzando con nuestra declaración esqueleto, seleccionando todas las columnas de la tabla de camiones y limitando nuestros resultados a Phi de tener un punto y coma al final aquí para una buena práctica. Y lo podemos ver bien. Por lo que estos son los primeros cinco resultados en nuestra mesa. ¿ De acuerdo? Entonces ahora lo que queremos tener es, en primer lugar, contemos el número de filas que tenemos. Y así este sólo va a ser nuestro número de filas, que puedes ver aquí hay 3,503. De acuerdo, pero ¿cómo podemos agrupar esto por los diferentes compositores que tenemos? Bueno, podemos hacer es hay una declaración genial que podemos usar llamada y grupo BY. Y aquí podemos poner la columna o columnas por las que queremos agrupar. Por ejemplo, agrupemos por la columna del compositor. Y ahora si ejecutamos esto, podemos ver aquí estamos obteniendo diferentes valores de conteo. En realidad ahora mismo no sabemos a qué se refiere esto. Eso está bien. Simplemente podemos sacar a nuestro compositor columna dos. Y podemos mostrar nuestra columna de compositor. Y podemos mostrar el resultado de la cuenta. Y podemos ver aquí, vale, Así que cuando el compositor es John Dolan, ya ves tenemos COUNTIF uno y correr el compositor es éste, tienes un recuento de uno, y así sucesivamente. Por lo que puedes ver aquí obtenemos los diferentes valores para las diferentes entradas que tenemos compositores. Y si queremos, podemos quitar la declaración de la mujer y especie de ver el resultado completo para todos los diferentes compositores. Por lo que puedes ver aquí algunos compositores tenemos más entradas para. La mayoría de ellos son muchos de ellos sólo tenemos una entrada para. Entonces en este caso, es realmente dependiendo del compositor es que podemos ver aquí. Ahora por supuesto, también podemos utilizar nuestra orden BY declaración y menos orden y también darnos un alias como número de pistas. Y ordenemos por un número de pistas, por un número de pistas en orden descendente, para que consigamos que primero el recuento más alto. Entonces volviendo a ejecutar esto, desplazándose de nuevo hacia arriba, acuerdo, así que el recuento más alto es en realidad aquellos en los que no tienes valores. Después de eso tenemos a Steve Harris, U2, jogger, slash Richards, y así sucesivamente. Por lo que puedes ver aquí ahora por cada compositor que
tenemos, también sabemos cuántos temas en este caso tenemos para ellos en nuestra mesa. Ahora también podemos agregar algunos filtros para esto, y existen dos tipos diferentes de filtrado. Vamos con un 1 básico primero y solo saquemos todos
los casos donde el compositor es nulo. Entonces, ¿dónde vamos a poner esto? Porque lo recordamos desde antes que el orden que tenemos declaraciones, y en realidad es importante para una consulta SQL. Y tenemos que asegurarnos de que todo esté en el orden correcto. Ahora el lugar que este fue ir es entre el del comunicado y el grupo BY. Entonces vamos a decir donde compositor no es nulo. Y ahora vamos a ejecutar esto y podemos ver aquí ahora el caso nulo se ha ido, pero ninguno de los otros valores aquí se cambia porque estamos agrupando compositores compradores aquí. Ahora es importante de nuevo que tengamos el orden correcto. Porque por ejemplo, si tomamos esto y lo ponemos aquí, entonces no va a funcionar. Por lo que necesitamos asegurarnos de que nuestro ordenamiento de las declaraciones que estamos utilizando en nuestra consulta SQL sea correcto. Muy bien, entonces hemos agrupado por o compositores y filtramos los casos donde el compositor no es nulo. Y así ahora tenemos el resultado para cada compositor. Tenemos el número de pistas que tenemos para ellos en nuestra base de datos. Entonces, ¿qué pasa si tratamos de seleccionar aquí una columna por la que no hemos agrupado. Por ejemplo, qué sucede si también tratamos de seleccionar la columna de nombre, que contiene el nombre de cada pista. Entonces si ejecutamos esto, entonces vamos a tener un error. Porque en cuanto usamos este grupo por declaración, estamos usando estas agregaciones. No podemos tener columnas aquí dentro que no sean una agregación ellos mismos o están usando el grupo por declaración aquí. Por lo que para poder mostrar la columna de nombre, en realidad
tendríamos que agrupar por compositor y nombre. Ahora si ejecutamos esto, veremos que esto no es particularmente útil porque debería ser que solo tengamos un registro. Y se puede ver en algunos casos aquí tenemos más. Pero realmente lo que estamos esperando aquí es que, ya sabes, los números aquí van a ser pequeños y hay, realmente no
hay mucha practicidad para agrupar, sino compositores en nombres. Podemos ver que realmente funciona. Y así la forma en que esta agrupación hace su primera, agrupamos por compositor. Y luego dentro de cada compositor, agrupamos por nombre de la canción. Entonces de esa manera, si tenemos dos compositores que han escrito una canción exactamente del mismo nombre, no
va a ser que los dos compositores vayan a agruparse,
sino que primero agrupamos por compositores, y luego dentro de cada compositor grupo, agrupamos por nombre. Y luego tenemos nuestra agregación, agrupación de compradores aquí. Si cambiamos el orden, entonces bucle, luego en los casos en que dos compositores han escrito el mismo nombre de la canción, entonces veríamos ese tipo de reflejado aquí. En este caso, tenemos de nuevo algunas de estas instancias porque recordamos que tenemos varios discos donde el compositor es de París y donde el nombre real es Rothschild. Pero también obtendríamos resultados adicionales porque podemos tener justo, si nos quitamos esta columna de compositor aquí, si dos canciones tienen el mismo nombre, entonces lo serían. Y ahora tenemos que tomar al compositor nosotros de aquí, entonces se agruparían en el mismo segmento. Entonces eso es algo importante a tener en cuenta, que el orden, y tomemos esto, vamos a sacar esto otra vez. El ordenamiento de la agrupación que estamos haciendo tiene efecto en el resultado final. Y así funciona la agrupación tomando la primera declaración, ese va a ser el primer grupo dentro de este grupo. Tenemos entonces la siguiente agrupación. Entonces esto va a hacer el segundo grupo, y luego así sucesivamente. Entonces, por ejemplo, intentemos hacer uso de esto de una manera más práctica. Y tratemos de encontrar el número de temas que
tenemos para cada compositor, para cada álbum. Por lo que vemos aquí tenemos una columna de ID de álbum. Entonces agrupemos primero por compositor, y luego agruparemos por ID de álbum. Y así vamos a mostrar también el ID del álbum aquí. Y así lo que podemos tener es ahora tenemos los resultados, que es para cada compositor, um, y para este disco específico, este es el número de temas que tenemos para este compositor y este álbum. Y en realidad podemos llegar a ser diferentes. Podemos ver aquí tenemos el mismo compositor, pero tenemos dos discos diferentes. Y este caso, estos son ID de álbum los cuales podemos encontrar, por ejemplo, en la columna arriba tenemos aquí el mapa del ID del álbum al nombre real del
propio álbum porque es buena práctica usar enteros y otros lugares para que si el título cambia o algo así, no
tienes que actualizar todas las bases de datos, sino solo la información donde está almacenada. Por lo que podemos ver aquí, tenemos los identificadores del álbum los cuales representan un álbum específico. Entonces en este caso tenemos un compositor el cual tenemos dos discos para y para el álbum 55 de este compositor, tenemos 20 temas y el álbum 54 de este compositor, tenemos 17 temas. Ahora por supuesto, no sólo necesitamos hacer la agregación de conteo aquí. También podemos hacer otros. Por ejemplo, podemos llamarlo, podemos hacer todos los que vimos previamente. Por ejemplo, tiene los milisegundos promedio aquí. Entonces como longitud de canción, y luego vamos a tener otra columna que nos da la longitud media de canción de cada álbum para cada compositor. Entonces vamos a agrupar por compositor primero. Entonces vamos a agrupar mi ID de álbum para cada combinación de álbum de compositor. Vamos a tener entonces el número de camiones así como la longitud promedio de la canción. Y eliminamos este error tipográfico aquí. Y así podemos ver esto es para lo que tenemos cuando el compositor es JC Fogarty. Y entonces el ID del disco aquí es 55. Aquí tenemos 20 pistas para ello en nuestra base de datos con una longitud promedio de canción de 224 mil milisegundos en este caso. Entonces podemos ver aquí en este caso, tampoco
necesitábamos agregar la columna de milisegundos al grupo por declaración porque es parte de la agregación. Entonces, mientras tengamos agregaciones aquí, entonces eso está bien. Pero las únicas columnas que se nos permite seleccionar, ya sea las columnas que se incluyen en el grupo por sentencia, o si los resultados de agregaciones de otra manera, como también vimos antes, vamos a obtener un error. Entonces, ¿qué pasa ahora si quieres hacer algún filtrado extra? Por ejemplo, digamos, bien, queremos conseguir todos los resultados, pero sólo queremos ver los resultados donde tenemos al menos 15 pistas. Si intentamos sumar esto a tu causa y decir, y donde el número de pistas es mayor o igual a 15, vamos a tener un problema porque no se ha realizado la agregación. Y así no podemos hacer el filtrado de la misma todavía. En realidad hay una forma diferente de que podemos filtrar aunque por resultados de agregación. Y la forma en que podemos hacer eso es después del grupo por declaración y antes del orden POR, podemos poner tener y aquí podemos poner la agregación por la que queremos filtrar. Por ejemplo, podemos decir Tener cuenta uno mayor o igual a 15. Y así esto significa tener el conteo de este resultado de agregación aquí siendo al menos 15. Ahora lo importante es, y vamos a ejecutar esto para ver si el resultado. Entonces puedes ver si nos desplazamos hacia abajo ahora, no
tenemos resultados que estén por debajo de 15 y el número de pistas. Por lo que podemos ver que la sentencia where aquí nos
permite hacer filtrado en una fila por pasos de fila. Nos permitiríamos hacer agregación en nuestra consulta. Entonces tenemos que usar la declaración de tener. Si queremos hacer filtrado por agregación resultados en el mismo tiempo que estamos haciendo la agregación en sí. Y no podemos poner esto en la declaración ganadora. Tenemos que poner esto en esta nueva declaración llamada tener. Ahora, aquí de nuevo, también podemos encadenar filtros. Por ejemplo, podemos decir tener un conteo mayor o igual a 15 y una duración media milisegundos de mayor o igual a 200 mil. Y así si corres esto, y antes teníamos 13 filas. Y si ejecutamos esto ahora, ahora tenemos nueve filas. Y podemos ver aquí en todos estos casos, el número de pistas es de al menos 15 y la duración promedio de la canción va a ser de al menos 200 mil milisegundos. Por lo que todavía podemos hacer el filtrado adicional también usando las mismas reglas que vimos en la declaración de capa. Es sólo porque estamos haciendo agregación, el filtrado para estos resultados de agregación de todo lo que estamos haciendo en la consulta tiene que ser puesto en esta declaración especial de tener y no se puede poner en la declaración where aquí.
36. 34JoinsHB: Por lo que anteriormente hemos aprendido sobre cómo hacer algunas agregaciones más geniales, también usando las sentencias de pastel de grupo así como usando tener para el filtrado de agregación. Pero uno del tipo de problemas
algo molestos que vimos es que la D optimizada aquí se representa como un entero en lugar de como un valor de nombre, por ejemplo, o un título aquí. Y eso por supuesto, debido a la naturaleza de cómo se construyen las bases de datos relacionales. Y también es muy buena práctica porque no tiene sentido repetir el mismo nombre. Cientos o incluso miles de veces dependiendo lo grande que sea la mesa que se mete en este disco ID valor aquí, Es mucho mejor tener un entero que represente el título del álbum. De esa manera, si se cambia el título del álbum, por ejemplo, se cambia la capitalización o algo así. No tenemos que ejecutar la actualización a través de todo lo demás. Pero también usar enteros es más eficiente en el espacio que tener aquí los valores de texto completo. Entonces verás esto muy a menudo que tenemos diferentes mesas. Y de nuevo, también nos enteramos de esto en una estructura relacional. Pero tendremos mesas diferentes para cosas diferentes. Por ejemplo, en, por ejemplo, cada disco sólo se va a mantener un seguimiento de por sí mismo y tiene un ID específico. cada artista aquí se hace referencia por su ID, pero cada ID en realidad representa a unos artistas específicos como podemos ver aquí. Y así esta es una manera realmente bonita de tipo de
datos divididos para asegurarnos de que ninguna tabla crezca demasiado grande o que tengamos innecesaria información de repetición grande en una tabla que se pueda hacer más eficiente. Por ejemplo, si realizamos un seguimiento del nombre del artista y del título del álbum en lugar del ID del álbum. En este caso, no tenemos la identificación del artista. Pero usted entiende mi punto de que si realizamos un seguimiento del nombre en lugar del id, no
es tan eficiente porque es mucho más eficiente hacer un seguimiento de los valores enteros aquí porque van a ser más pequeños tomados un espacio en lugar de repitiendo, por ejemplo, el título para los que están a punto de Irak, te
saludamos cientos o miles de veces dependiendo de cuántas entradas no tengamos son tablas diferentes. Y de nuevo, también es buena práctica porque entonces si queremos hacer un cambio a un título, porque por alguna razón notamos que hicimos un error tipográfico o algo así cuando lo ponemos, en lugar de tener que hacer todos estos cambios y cada sola tabla diferente que tiene este valor de título, sólo
podemos cambiarlo en el, en este caso, por ejemplo, la tabla Álbum. Y entonces cualquier disco al que hace referencia este ID simplemente encontrará el título correcto, en lugar de que tengamos que ir por cada tabla celular, ver si hay un título ahí y si hay actualizándolo. De esta manera, todo es una especie de estructura agradable que aún está conectada, pero estamos haciendo la conexión y de una manera mucho más inteligente que
hace que todo sea mucho menos propenso a errores y además es más eficiente. Por lo que doblas ahí dentro. Pero por supuesto ahora nos encontramos con estos problemas como vemos aquí, donde tenemos el ID del disco. Pero realmente, por supuesto en este punto nos gustaría ver el nombre del álbum. Entonces, ¿cómo podemos hacer esto? Entonces antes que nada, lo que voy a hacer es que voy a comentar esto porque me gustaría volver a esto más adelante para que aquí podamos implementar la solución. Pero primero, me gustaría simplemente mirar el caso de uso más simple para esto. Y lo que vamos a hacer es que vamos a escribir un comunicado de unión donde podamos unir dos mesas juntas. Y vamos a usar nuestra mesa de artista al igual que aquí lo hace la mesa de álbumes. Entonces vamos a llevarnos la mesa ABO aquí. Y para cada álbum, nos vamos a unir en la mesa de artistas. Ahora sabemos que el valor del artista aquí se refiere a la clave del artista aquí, para que
sepamos, por ejemplo, cuando vemos artistas id y uno aquí, nosotros, esto corresponde al nombre ac-dc. Entonces la forma en que podemos unir estas tablas juntas es usando una sentencia SQL llamada join. Entonces echemos un vistazo a, Vamos primero a escribir son sólo una especie de sentencias SQL esqueleto. Vamos a seleccionar todo de. Y empezaremos solo con la mesa de álbumes, que tenemos aquí. Recuerda en este caso no necesitamos las comillas a su alrededor
porque hicimos ese cambio atrás donde realmente lo renombramos. Y limitemos nuestros resultados a cinco. Por ahora. Adelante y corre esto. Muy bien, entonces ahora tenemos nuestra mesa de álbumes aquí, pero sigamos adelante y unámonos a los artistas. Entonces para hacer eso, vamos a tener nuestra declaración selecta y a definir también las columnas aquí que vamos a tener la declaración desde. Y ahora vamos a tener después una declaración de unión. Entonces esta va a ser la mesa, y esta va a ser la segunda mesa a la que vamos a sumar. Por lo que queríamos unirnos a esta mesa, aquí, a la mesa de artistas. Pero ahora necesitamos precisar qué es lo que hace la norma conjunta, porque ahora mismo no hay manera de
que sepa qué columna deben coincidir estas tablas con eso? Ahora por supuesto, ya sabes, se puede decir, Vale, bueno el título aquí es ID de artista. Y si entramos en la columna del artista aquí también se llama Artist ID. Pero recuerda que en algunos casos podemos simplemente llamar a este ID porque es el ID y se implica que es el ID del artista. Pero en otra tabla, puede llamarse el ID del artista para que sea más explícito que esto se refiere al ID de los artistas porque podemos tener otras ideas, por ejemplo, el ID del álbum. Por lo que ahora necesitamos especificar en qué se deben unir estas cosas con estas dos mesas. Y eso lo hacemos usando la declaración honesta diciendo dónde. Y ahora decimos, vale, donde el disco oh, bueno, eso fue auto completado por agarre de datos. Pero hagámoslo correctamente. Donde el álbum y ahora en la columna del álbum, vamos a encontrar al ID del artista. Entonces donde el álbum artista ID, que tenemos aquí es igual. Y ahora queremos unirlo a la mesa de artistas. Por lo que queremos decir donde el ID del artista del álbum es igual
al ID del artista que encontramos dentro de la tabla del artista. Ahora bien, esta es la afirmación sin embargo. También acabamos de obtener autocompletar para comprar de datos crecieron. Y si realmente miramos nuestros formatos de mesa, podemos ver aquí. Y la razón por la que sabe esto es porque podemos mirar el disco y el ID del artista aquí tiene una clave extranjera que enlaza con el ID del artista en la tabla del artista. Entonces está justo aquí. Por lo que podemos ver que existen estos enlaces claves foráneas que son realmente agradables porque especifica cómo estas columnas están relacionadas con las diferentes tablas. Pero en realidad podemos usarlo aquí una declaración honesta y vamos a decir, OK. Entonces, solo ejecutemos esto para que realmente podamos ver los resultados. Para que podamos ver el arte. Por lo que tenemos nuestro ID de álbum y tenemos nuestro título. Estos provienen de la mesa de álbumes aquí. Entonces tenemos nuestro disco aquí, cual tiene el ID del álbum y el título. Pero ahora tenemos dos columnas más, tarjeta, el ID de artista y otro ID de artista. Y eso es porque tenemos dos artistas en estos, uno de la columna ID del álbum y otro de la columna del artista. Entonces en este caso, en realidad estamos, Nos está mostrando que este es el ID del artista de la columna del álbum, y este es el ID del artista de la columna del artista. Y podemos ver aquí, por supuesto que van a emparejar porque nos hemos unido en estas mesas con la condición de que el ID de artista y tabla de
álbumes sea igual al ID de artista en la tabla de artistas. Entonces podemos ver aquí que se une. Ahora estos valores aquí coinciden. Y ahora tenemos la columna de nombre, que viene de la tabla de artistas aquí. Entonces podemos ver que hemos tomado dos bases de datos o dos tablas, más bien, la tabla de esquema y la tabla de artista. Y acabamos de pegar o como que los pegamos juntos en el lado que están pegados juntos donde esta columna de ID de artista es igual, lo que podemos ver aquí. Ahora en este punto, sería realmente bueno empezar a usar alias de tabla. Entonces por ejemplo, vamos a conseguir esta mesa sí arte. Y aquí nos podemos dar, por ejemplo, ALP. Y así podemos especificar ahora en lugar de decir álbum dot artist ID, porque estamos usando alias de tabla, vamos a decir L dot artist ID. Y aquí vamos a decir arte. Entonces esta es la primera forma que podemos especificar, pero también probablemente no queramos seleccionar todas las columnas. Probablemente, quizá queramos el ID del álbum, pero el ID del álbum viene de la mesa del álbum. Por lo que es bueno especificar que queremos el ID del álbum de la mesa del álbum. Digamos que queremos el título de la mesa de álbumes. Vas a decir desde la mesa del álbum, queremos el título. Y digamos que queremos una de las identificaciones de artista, pero no las queremos a ambos. Y podemos escoger y elegir si queremos el del álbum. Aquí, el ID del artista, o si queremos el de la mesa del artista, no
hace diferencia porque van a ser mismo porque nos unimos a ellos. Pero es agradable escoger uno para que aquí no tengamos valores duplicados. Y también queremos el nombre del propio artista, que proviene de la mesa del artista. Entonces vamos a ir de la mesa de artista, queremos usar el nombre. Y así podemos ejecutar esto. Y podemos ver ahora todo está mucho más limpio específicamente porque no tenemos duplicados de artistas, pero es bueno usar los alias de la tabla para que aquí nos estemos refiriendo a las tablas adecuadas. Y por supuesto no necesitamos usar una tabla ASUS. También podemos usar los nombres completos de las tablas, pero es más agradable usar alias porque lo hace más corto. Pero es bueno especificar exactamente qué columnas desea seleccionar. Porque muchas veces, sobre todo cuando las tablas se
hacen más grandes, van a ser muchas columnas que probablemente no quieras usar. Y así es mejor simplemente especificar qué columnas exactamente quieres usar. No sólo lo tienes por unirte. Por ejemplo, echemos un vistazo. Nuestro camión acarreo aquí tiene un montón de columnas. Entonces por unirnos a otra mesa que es aproximadamente igual de grande, entonces por supuesto sólo vamos a tener un montón de columnas. No vamos a usar muchos de ellos. Entonces, por lo tanto, ya sabes, es una buena práctica sólo asegurarnos de eso y empecemos a cerrar algunas de estas porque también están ocupando mucho espacio. Por lo que es una buena práctica simplemente seleccionar las columnas que realmente quieres a menos que quieras usarlas todas. Pero incluso entonces es bueno saber que no quieres tener columnas duplicadas teniendo al artista que necesito dos veces, Eso es sólo un desperdicio de espacio. Por lo que es una buena práctica especificar cuáles quieres escoger. Entonces podemos ver aquí, esta es la afirmación que solíamos unirnos al disco y a la mesa de artistas juntos. Y esta unión se hizo en la columna donde el ID del artista y la tabla del álbum es igual al ID del artista y a la mesa del artista. Y por supuesto que podemos quitar o una declaración de límite aquí. Y eso nos va a dar la respuesta completa para todos estos casos. Y ahora algo que es importante saber es que lo que está sucediendo aquí en realidad se llama unión interna. Y podemos especificar la unión interna si queremos. A pesar de que si acabamos de utilizar la declaración de unión en sí, no lo es, va a implicar la unión interna, pero con los medios de unión internos es que cuando alguno de estos valores
es nulo, no se va a unir a ellos. Entonces, por ejemplo, si tuviéramos un caso aquí donde el ID del artista es nulo, entonces esa fila se va a soltar. O si aquí hay un ID de artista, que no está representado en la tabla de artistas, entonces estos valores no se van a incluir. Entonces lo que significa una unión interna es que solo estamos buscando o solo estamos obteniendo los resultados donde esta tabla o estos valores tienen una coincidencia aquí. ¿ Y estos valores tuvieron un partido aquí? Ahora hay otras alegrías que podemos hacer donde si no tenemos una identificación de artista, por ejemplo, aquí
dentro, o tenemos una identificación de artista, pero aquí no está representado que guardemos esa información. Pero en este caso, si estamos usando la unión interna, lo cual está implícito cuando usamos la declaración conjunta, solo la simple declaración conjunta. Entonces solo buscamos la intersección de estos dos. Sólo estamos buscando dónde este valor y este valor, existen en ambos lados. Y así si uno de los valores no existe a ninguno de los lados, que no vamos a tener esa habitación. Esto es importante saber porque si un valor está presente en alguna parte, pero no está presente en otro lugar, esas filas se van a quitar. Entonces sólo ten en cuenta eso. Esto de aquí es lo que se llama unión interna. Está bien, entonces ahora que sabemos cómo funciona el join, Vamos a usar esto. Todos ellos. Nuestra declaración anterior que hemos comentado,
espera más temprano ahora aquí. Entonces vamos a volver a ejecutar esto. Y lo que queremos hacer es que queremos reemplazar esta columna de ID de álbum en su lugar por el nombre del álbum. Entonces, ¿cómo podemos modificar aquí nuestra declaración para sacar el nombre externo? Entonces lo que vamos a hacer es que nos vamos a unir y vamos a hacer un join interno. Pero eso está implícito cuando escribimos aquí la declaración conjunta. Nos vamos a unir a esta mesa de temas aquí, la mesa de álbumes, a esta. Entonces vamos a unirnos a aquí, a la mesa del álbum. Voy a usar la taquigrafía aquí afuera. Y aquí voy a usar,
bueno, sólo la taquigrafía TR. Y estoy realmente especifico cada una de las columnas ahora para
asegurarme de que no haya confusiones o errores por si acaso. Por ejemplo, el disco también tiene una columna llamada compositor, porque entonces va a haber un conflicto de dos. Escojo un compositor de la pista o de la mesa de álbumes. Entonces ahora voy a asegurarme de especificar cada una de las referencias de columna que tengo para
asegurarme de que no haya confusión o errores que sucedan. Entonces todos estos casos cuando lo estamos usando en la mesa de temas, porque ahora estamos trayendo en la mesa del álbum. Por lo que en la mesa de camiones otra vez, vamos a hacer una unión interna con la mesa del álbum. Y nos vamos a unir en donde el,
usando la taquigrafía para la tabla de atraer, donde el ID del álbum es igual a V álbum ID de la tabla del álbum. Y ahora, en lugar de seleccionar aquí el ID del álbum, quiero seleccionar extender el título del álbum de la tabla del álbum. Entonces si ejecutamos esto y aún tenemos nuestra referencia de ID de disco aquí abajo. Entonces en este caso, en realidad podemos hacer el agrupamiento por el título del álbum porque estamos realizando el join y luego realizaremos la operación de agregación. Por lo que puedes ver aquí primero estamos realizando la unión, luego estamos realizando la operación de agregación de agrupamiento. Entonces en lugar de unirnos al ID del álbum, AHORA vamos a unirnos al título del álbum. Nos va a dar el mismo resultado, por supuesto, porque la identificación sólo se refiere a un título. Entonces vamos a correr eso una vez más. Y ahora podemos ver que nuestra identificación ha sido sustituida por el título que vino de la tabla de álbumes aquí. Y lo conseguimos porque cada razonamiento, la tabla de temas, cada ID de álbum aquí, nos unimos en el ID del álbum aquí, y actualizamos nuestra declaración selecta para en su lugar extraer el título de la mesa del álbum, donde nuestra pista mesa y nuestra mesa de álbumes se unieron en. Por lo que podemos recordar aquí nos unimos a nuestras dos mesas también en las columnas de ID del álbum. En este caso, se llamó el ID del álbum y mi D en ambos casos, y en algunos casos, por ejemplo, en la columna del álbum, tendría sentido simplemente llamar a este DID porque estaría implícitamente implícitamente implícitamente implicado que el ID representaría el ID del álbum. Entonces en caso de que yo sólo diría identificación aquí. Y entonces sólo nos referíamos a la columna ID de la tabla de álbumes. En este caso no lo hace. Pero sólo digo que estos dos no tienen que ser siempre iguales. En este caso, resulta que son iguales, pero también hay muchos casos en los que no serán iguales porque la clave primaria simplemente se llamaría ID, lugar de tener el nombre de la tabla o algo que también especifique qué ID exactamente es. Por lo que podemos ver las combinaciones son muy útiles por la forma en que se construyen las bases de datos relacionales, cual es realmente útil y eficiente porque nos
permite separar la información y simplemente hacer un seguimiento de diferentes cosas por separado para asegurarse de que no todo sólo está afectando a todo lo demás que nuestros almacenamientos son eficientes. Y luego cuando hacemos actualizaciones, estas actualizaciones sólo para, uh, ser aplicadas en un solo lugar. Y luego cuando usamos combinaciones que básicamente propagan en todas partes porque estamos usando identificadores en todas partes. Por lo que mucho de esto es muy buena práctica lo que lleva a un buen rendimiento, un buen almacenamiento, y también conduce a una actualización mucho más fácil. Y entonces podemos usar las declaraciones conjuntas porque tenemos todas estas relaciones entre nuestras diferentes mesas para luego llenar la información adecuada. Por ejemplo, reemplazar aquí el ID del álbum por el título del álbum. Y podemos ver aquí ninguna de nuestras otras declaraciones cambió realmente excepto porque ahora ya no estamos usando V ni sacando el ID del álbum. Tenemos que reemplazar en cambio la agregación, el título del álbum en lugar del ID del álbum, porque el ID del álbum ya no está en la declaración selecta aquí. Y luego lo otro que hicimos como agregar los alias para nuestra tabla para asegurarnos de que no haya confusión. Por ejemplo, cuando tenemos nombres de columna duplicados para asegurarnos de que nos estamos refiriendo a la columna correcta desde una tabla específica. Entonces por ejemplo aquí refiriéndose a la columna del compositor de la mesa del camión, porque podría ser que la columna del compositor también pudiera existir en la tabla del álbum. Entonces para asegurarnos de que no lo
entendemos, especificamos qué tabla, pero quiero elegir por si acaso si estás confundido por lo que acaba de pasar, si haces doble clic en ella, se quita este panel de navegación de la izquierda y luego vuelve a
hacer doble clic sobre él y lo trae de vuelta justo como nota al margen. Pero sí, como se puede ver, las combinaciones son realmente bonitas porque nos permite unir toda esta información que se divide intencionalmente por la estructura de las bases de datos relacionales.
37. 35LeftRightRightFullJoinsHB: Muy bien, Así que ahora hemos aprendido sobre un join, específicamente dentro de las juntas donde miramos la intersección entre dos tablas. Pero en este caso, sólo
estamos limitados a la intersección. Y puede haber algunos casos en los que tengamos datos en algún lugar y puede que no haya un valor correspondiente en otro lugar. Por ejemplo, echemos un vistazo a esta tabla de líneas de factura. La línea de factura solo tiene información de compra sobre quién o qué se compró, qué factura era, qué pista se compró al precio, así
como la cantidad comprada. Y podemos ver aquí tenemos una referencia de ID de pista. Y si solo miramos eso, aunque probablemente ya sepas dónde está el nombre, podemos ver aquí, el ID del camión es una referencia clave extranjera a la identificación del camión en la mesa de camiones. Entonces si abrimos la tabla de pistas, podemos ver aquí tenemos los diferentes identificadores de pista. Entonces contemos cuántas pistas tenemos en la mesa de camiones primero. Entonces sigamos adelante y seleccionemos y solo vamos a contar uno de nuestra mesa
de camiones. Y no vamos a hacer nada más. Y así podemos ver aquí tenemos 3500 y tres filas diferentes. Y como cada fila tiene un ID de Track único porque el ID del camión es la clave principal, también
podemos deducir que tenemos 3500 y tres pistas únicas. Pero sólo porque tengamos esas muchas pistas, no quiere decir que cada pista que se compró, tal vez fue tal vez no lo fue. Averiguémoslo. Entonces si miramos la línea de factura, ¿cómo podemos contar cuántas pistas diferentes se compraron? Actualmente, tenemos nuestros métodos de agregación, pero en este momento no tenemos una herramienta específica aún para entender exactamente cuántas pistas únicas se compraron aquí. Ya que algunas pistas se pueden comprar más de una vez, ya que diferentes personas pueden comprar la misma pista. Tan a menudo nos enteramos de esto. Bueno, lo que podemos hacer es hacer una ligera modificación a nuestra declaración de conteos aquí, que está dentro. Se puede poner la palabra clave distinta, que va a buscar ocurrencias distintas. Pero en este caso ya no se nos permite usar el número 1. Tienes que hacer una referencia específica a una columna. Por lo que vamos a hacer referencia a la columna de ID de pista dentro de la línea de factura. Por lo que vamos a referir aquí la pista de la D y vamos a actualizar nuestra tabla de pista a la tabla de líneas de factura. Entonces vamos a cubrir esta afirmación. En tiempo de guerra aquí estamos haciendo la agregación de conteo. Pero en lugar de solo contar todas las ocurrencias, queremos saber el número de ocurrencias únicas y el ID de pista. Por lo que queremos saber cuántos ID de pista diferentes y presentes dentro de esta columna de ID de pista. Y así es lo que el distintivo nos permite hacer aquí dentro, nos
permite contar ocurrencia única. Nos permite contar distintas ocurrencias de artículos separados dentro de aquí. Entonces, de nuevo, es importante que realmente hagamos referencia a la columna donde
queremos encontrar el número de ocurrencias únicas dentro. Entonces si ejecutamos esto, podemos ver en la tabla de líneas de factura y en la columna de identificación de camión, tenemos ciento, diez mil novecientos ochenta y cuatro pistas diferentes o más bien únicas. Eso no quiere decir que cada camión solo aparezca una vez es posible que se presente más de una vez. Esa no es la información que estamos tratando de obtener. Acabamos de saber que 1984 los identificadores de pista únicos aparecen en esta columna de identificación de camión dentro de la tabla de líneas de factura. Entonces, ¿qué significa esto y por qué es esto importante? Bueno, si queremos tal vez unirnos a nuestra pista y a nuestra tabla de líneas de factura, eso significa que algunas de nuestras pistas en realidad sobre un 1000 o incluso sobre un 1500 pistas no tienen ninguna factura para bucle, lo que significa que los datos no serán utilizados porque estamos mirando la intersección. Pero a veces no queremos perderlo. A veces si no hay factura a ella, sólo
queremos mantenerla como ustedes saben, queremos mantenerla ahí, pero sólo queremos
tener un dicho de que no hay datos para éste. Y así no podemos hacer eso con una unión interna porque la unión interior busca la intersección. Entonces vamos a escribir una consulta donde tomamos nuestra tabla de seguimiento aquí. Y a cada pista, también
adjuntamos básicamente la información que tenemos aquí desde nuestra tabla de líneas de factura. Ahora, para cada pista, entonces vamos a tener al menos una factura. Ahora podemos tener múltiples facturas, lo que significa que vamos a conseguir algunas filas duplicadas donde la información sobre la pista misma como un duplicado. Pero entonces la información sobre la factura va a ser separada. Entonces para hacer eso, o lo vamos a hacer es que vamos a decir selecto. Y vamos a empezar con selecto todo de la tabla de temas. A menos que le dé a esto una taquigrafía TR. Y ahora vamos a hacer un join de izquierda. Y vamos a unirnos a ella en la tabla de líneas de factura. Y sólo vamos a dar esto también taquigrafía I L. Y entonces nos vamos a unir en donde la camioneta ID de la camioneta. Y ya podemos ver grupo de datos
nos lo está sugiriendo por la referencia de clave extranjera. Pero donde el ID del camión de la vía es igual al ID del camión de la tabla de líneas de factura. Entonces de nuevo, queremos igualar donde esta identificación de camioneta aquí es igual a la identificación de camión que tenemos aquí. Y si tenemos más de una ocurrencia, por ejemplo, para nuestra primera pista aquí, entonces vamos a tener duplicados los datos de la tabla de camiones. Entonces vamos a tener dos filas aquí, pero los datos de la factura sobre eso se van a adjuntar ella va a ser una fila para básicamente cada factura, cada factura separada que tengamos para ella. Entonces no vamos a tener filas duplicadas completas. Podrían ser las partes de ella, por ejemplo, de nuestra tabla de seguimiento aquí, se pueden duplicar, pero luego las facturas correspondientes si hay más de una factura, por ejemplo, si hay tres facturas por primera vez aquí, para los que están a punto de rock, te saludamos y vamos a tener tres filas para esto. Seguimiento, la información va a permanecer igual, pero cada fila va a tener información sobre una factura separada. Pero todo esto estará disponible para nosotros para cada fila, para cada registro individual que tengamos en nuestro ahora la mesa de unión. Entonces sigamos adelante y solo ejecutemos esto para ver el resultado. Y así como podemos ver aquí, ahora
tenemos de nuevo la información cuando hay columnas
duplicadas sobre qué tabla proviene la columna. Tenemos información de la tabla de pistas. Y luego si nos desplazamos hacia la derecha, también
tenemos la información de la tabla de líneas de factura, que podemos ver aquí. Y entonces, sí, estas van a ser nuestras mesas que ahora están unidas. Pero lo importante es, y echemos un vistazo al número de ideas
de pista de nuestra columna de pistas que aparecen aquí. Entonces vamos a contar de manera distinta, y nos vamos a centrar en el ID del camión de la columna de la pista, ya que no todas las pistas aparecen en nuestra tabla de líneas de factura aquí, pero todas las pistas se llevan un seguimiento en nuestra tabla de pistas aquí. Entonces veamos el número único de identificadores de pista que tenemos en esta mesa de unión, centrándonos en el ID de camión de columna que vino de la tabla de pistas. Entonces corriendo esto, podemos ver que tenemos 3500 y tres pistas únicas, que es exactamente lo que esperaríamos. Pero para esas pistas, para no todas, en realidad
tenemos datos de factura. Entonces, sólo vamos a seleccionar todo de nuevo aquí. Pero centrémonos en encontrar los casos en los que no
tenemos datos de factura para ver cómo se ven esos. Entonces vamos a decir donde la factura línea camioneta ID. Y ahora en los casos en que no tenemos datos, estos valores van a ser nulos. Entonces vamos a buscar donde una de las columnas de nuestra línea de factura es nula. Podemos utilizar el ID de camión. También podemos utilizar cualquier otra columna de la línea de factura. Porque si tenemos una pista que
no tiene datos correspondientes y la tabla en la que la estamos uniendo, entonces las filas resultantes para ese conjunto sólo van a ser nulas. Entonces si ejecutamos esto, puedes ver aquí tenemos, por ejemplo, el camión ID 7. Y si miramos, no tenemos datos de factura que le correspondan. Y así es lo que hace nuestra unión izquierda con una unión de izquierda, es que toma toda esta columna y toma la primera, lo
siento, toma toda la primera mesa, toda
esta mesa aquí. Y se une a ella en, o se une en otra mesa y un se une en esta condición. Pero si no hay instancia correspondiente en nuestra segunda tabla, entonces todavía vamos a guardar la información de esta primera mesa o de ésta una mesa izquierda es una especie de lo que se puede pensar de ella. Pero debido a que no tenemos información correspondiente de la otra tabla, los valores que tenemos aquí dentro van a ser nulos porque no
hay información correspondiente para agregar a esto. Entonces, ¿en qué se diferencia esto de la unión interna que teníamos antes? Bueno, si le quitamos la izquierda aquí, y si volvemos a correr esto, podemos ver aquí nuestros resultados van a ser nada. No hay fregadero, ni fila donde haya un valor nulo dentro de esta línea de factura. Y eso es porque cuando estamos haciendo un join interno, estamos mirando la intersección. tanto que si estamos haciendo un join de izquierda, estamos guardando toda la información desde la primera tabla. Y si existe información de la segunda tabla, vamos a sumar eso. Pero para los casos en que no existe esta información, por ejemplo, en los casos en que el tractus no tiene factura y la tabla de líneas de factura. Entonces, porque aún tenemos las columnas y la tabla de unión resultante, estos valles aquí sólo van a ser nulos porque no hay nada al respecto. Y así podemos ver eso es lo que hace la unión de izquierda, es que no tiramos las filas que no tienen datos correspondientes en la otra tabla. Lo cual a veces puede ser bueno. A veces tampoco es bueno porque eso también significa que tus tablas resultantes van a ser mucho más grandes. Porque si no hay, no hay datos correspondientes, entonces en la intersección esto se
tiraría y la tabla resultante sería más pequeña, mientras que ahora nos estamos aferrando a ella. Entonces dependiendo de lo que necesites, si aún quieres conservar información que puede no tener información correspondiente en la otra tabla, entonces quieres usar una unión de izquierda. Otra alternativa es una unión derecha, que veremos en un segundo, o una unión completa o una unión externa completa. Pero si solo quieres enfocarte en la intersección, entonces quieres asegurarte de que usas una unión interna, que también puedes taquigrafía solo teniendo aquí la unión. Por lo que mencioné otros dos tipos de combinaciones. Entonces tenemos la izquierda se unen, que va a correr todo el asunto. Entonces tenemos a la izquierda unirse. Ahora la izquierda se une de nuevo se centra en mantener cada valor desde aquí y unirse a los datos de esta tabla aquí. Y en los casos en que no hay coincidencia de la segunda tabla, simplemente
seguimos guardando los datos de la primera tabla que los valores correspondientes de la segunda tabla sólo vamos a ser no. Ahora también hay algo llamado un derecho de unión y un derecho de unión. La diferencia es que en lugar de tener esta tabla tipo de mantener toda la forma la base y mantener los valores nulos. Por ejemplo, voy a tener esta mesa. Y así la derecha se unen y la izquierda se unen o simplemente una cuestión de perspectiva, porque una unión derecha, qué es una unión derecha, es básicamente una unión de izquierda. Pero volteamos el orden de la mesa así. Entonces eso es lo que es un derecho de unión. Y así, ya sabes, es más fácil simplemente ir siempre con una unión a la izquierda y solo tener su orden de mesa en consecuencia. Y que siempre estás usando la primera mesa como base para unirte. Porque a la izquierda se unen, si hay algunos valores aquí, por ejemplo, en la columna de pista. Y si ejecutamos esto, podemos ver que
no hay instancias en nuestra línea de factura donde tengamos un ID de camión que esté presente en la línea de factura, eso no está presente en la tabla de vías. No hay instancias. Entonces si estamos haciendo una unión de izquierda en la línea de factura, entonces este resultado aquí va a ser nulo. Pero si hicimos un derecho unirnos ahora, usando nuestra sintaxis actual que vamos a obtener el resultado que tenemos antes. Porque ahora también estamos guardando la información de la mesa de camionetas y van a haber algunas pistas que se llevan el seguimiento de una vieja mesa de camiones que
no tienen una factura correspondiente en la tabla de líneas de factura. Entonces podemos ver una izquierda y una derecha unirse o simplemente, básicamente
son lo mismo. Es solo el orden en el que estamos mencionando estas tablas es diferente. Por lo que puedes usar una unión a la izquierda en lugar de una unión a la derecha y simplemente voltear el orden de las tablas. Y esa suele ser una forma mejor de hacerlo solo para asegurarte de que mantengas una forma consistente de pensar. Pero claro que siempre tienes la opción de hacer esto. Ahora, también hay otro tipo de join, que es ¿y si queremos mantener toda la información de ambas tablas? ¿ Y si tenemos algunos datos y nuestra tabla de líneas de factura que no tenga valores correspondientes en la tabla de seguimiento. Y tenemos algunos datos en la tabla de seguimiento que no tiene valores
correspondientes en la tabla de líneas de factura. Y queremos quedarnos todos estos. Y en los casos donde tenemos datos en la tabla de líneas de factura, pero no en la pista. Queremos que los valores de la, para que las columnas que provienen de la tabla de pistas sean nulos. Y en los casos donde tenemos información sobre la pista, pero no sobre la línea de factura o ningún valor correspondiente en la línea de factura. Queremos que los valores en las columnas que corresponden a la línea de factura sean no y que los valores para que el camión siga ahí para que tengamos la intersección así
como la información de cada cinta. Y así esto se llama unión completa, o también se llama unión externa completa. Ahí, lo mismo. Entonces otra vez, qué grupo lo que hace esto es que estás mirando la intersección así
como todos los valores en ambas tablas que no tienen valores correspondientes en la otra. tanto que con la unión izquierda, estás mirando la intersección más todos nuestros valores en la primera tabla que no aparecen en la segunda tabla. A right join, estás mirando la intersección más todos
los valores de la segunda tabla que no aparecen en la primera tabla. Perdón, sí, estos son los diferentes tipos de combinaciones que están disponibles para nosotros. Recuerda, ya sé, si estás aumentando o uniendo tamaños básicamente yendo de interior a izquierda o derecha a una unión externa completa. Vas a conservar más datos y también
conservas los datos que pueden no coincidir en la otra tabla. Pero eso también significa que tus tablas resultantes van a ser una más grande. Ahora, por lo general cuando estamos haciendo combinaciones, los tamaños de nuestras tablas sólo van a aumentar porque podemos tener, por ejemplo, una sola instancia en la tabla de pistas puede tener varias facturas correspondientes en la tabla ligera de facturas. Entonces si tenemos un 100 pistas y cada pista tiene tres facturas, nuestra mesa va a crecer porque necesitamos hacer seguimiento de cada una de esas voces internas también. Entonces solo piensa en eso. Incluso si comienzas con una mesa pequeña, tamaños de
tus mesas pueden crecer porque estás buscando todas estas intersecciones. Entonces otra vez, ya sabes, úsalo en función de tus necesidades, pero no solo uses combinaciones
externas izquierdas o derechas o completas si no vas a usar los datos porque la tabla correspondiente que va a ser grande. Y es mejor sólo mirar la intersección si en realidad sólo estás interesado en todos los casos donde las columnas que provienen de cada tabla o ambas NO nulas. Básicamente quieres asegurarte de tener toda la información de la tabla de seguimiento que tiene información correspondiente en la tabla de líneas de factura. Por lo que solo centrándose en la intersección y esos casos solo asegúrate de que solo uses la unión para reducir el tamaño de tu mesa, que va a ser más eficiente. Y también va a llevar a un mejor rendimiento. Pero otro sobre el último, si sí tienes instancias donde quieres asegurarte de poder observar esa información, aunque no haya valores correspondientes en la otra tabla, siempre
tienes la opción de usar la izquierda o la derecha se une, así
como las combinaciones completas son combinaciones externas completas como se llama a su nombre completo.
38. 36SelfJoinsHB: Ahora hemos visto que diferentes tipos de combinaciones, interior izquierda frita externa, donde podemos unir la información de una tabla a la información que tenemos en otra tabla. Pero en realidad no hay nada las declaraciones conjuntas que dicen que no se puede unir una mesa sobre sí mismo. En realidad, podemos hacer eso. Podemos hacer un auto join donde tomamos la información de una mesa y la unimos sobre sí mismo. Entonces eso es lo que vamos a ver ahora. Y también vamos a ver cómo podemos usar, o más bien cómo podemos unirnos en múltiples condiciones. Desde antes, siempre estábamos justo emparejando. Por ejemplo, el ID del camión y la línea de factura tiene que ser igual al ID del camión en la tabla del camión. Pero también podemos usar múltiples condiciones como lo hicimos en el filtrado por ejemplo. Entonces echemos un vistazo a eso. Primero que nada, solo selecciona todo de nuestra tabla de líneas de factura, nos
da la taquigrafía IL. Y luego nos vamos a unir de nuevo en la factura, En la tabla de líneas de factura. Y vamos a darle a esto un ILA taquigrafía, sólo línea de factura y luego una para condicional. Y así nos vamos a sumar, en primer lugar, queremos unirnos en donde la línea de factura y el ID de factura son iguales. Entonces en este caso quiero buscar una factura y
quiero ver qué otras compras o tal vez hecho en esa factura. Y así veremos por qué exactamente. Eso haremos más adelante en este video. Entonces, solo unámonos en donde los identificadores de factura aquí son los mismos. Por lo que podemos ver podemos tener diferentes identificadores de línea de factura, pero todos estos diferentes artículos forman parte en este caso de la misma factura. Entonces por ejemplo, en esta factura, la persona compró dos pistas diferentes. Y así podemos ver aquí tenemos dos pistas diferentes representadas. Entonces unámonos en donde la línea de factura, el ID de factura es igual al ID de factura de nuestra segunda tabla de líneas de factura aquí, o la misma tabla de líneas de factura. Pero añadamos también otra condición aquí donde decimos que queremos que el ID de pista aquí sea más grande que el ID de camión en nuestra primera tabla. De esa manera sólo podemos asegurarnos de que no tengamos un montón de partidos cruzados, pero que tengamos al menos algún tipo de orden. De nuevo, veremos aquí la aplicación en un segundo. Por lo que sólo tomaré nuestra factura línea de camioneta ID y queremos hacer tener esto. Queremos que el ID de camión del cuento tradicional sea
mayor que el ID de camión de la tabla inicial. Ahora el orden aquí en realidad no importa mucho porque todo es algo simétrico. Pero solo ayuda a visualizar esto en tu cabeza. El segundo es tipo del que se quiere ver como referencia. Y este de aquí puedes pensar en nosotros, la base. Y se puede ver aquí la sencillez de agregar en
condicional adicional a nuestras declaraciones de unión es sólo poniendo un fin aquí. Entonces estamos diciendo con esta condición, y luego podemos simplemente usar las manos para encadenar en condiciones adicionales. También podemos usar una guerra es si queremos. Entonces, al igual que vimos en los casos donde, se aplica
el mismo tipo de lógica si se quiere hacer más lógica condicional aquí por cómo exactamente queremos unir estas tablas juntas. Entonces de nuevo, esto va a ser básicamente lo mismo que lo que vimos en el filtro en los casos. Excepto ahora aquí lo estamos haciendo en el
comunicado on que hace referencia a la declaración conjunta que tenemos arriba. Entonces pongamos aquí nuestro punto y coma y vamos a correr esto. Entonces los resultados que obtenemos de esto, podemos ver aquí que tenemos, tenemos todas las mismas columnas, una para cada tabla. Tenemos el ID de línea inversa de las primeras tablas aquí y todos los demás valores correspondientes. Y entonces tenemos las mismas columnas de la segunda tabla, la línea de factura a, como la llamamos. Y otra vez aquí del MOS en ID, el ID de factura, el ID de camión, y el precio unitario. Pero también podemos ver que aquí tenemos el ID de camión de la segunda mesa a la que nos sumamos en este cuatro. Y el ID de camión del primero es a, como por nuestra segunda condición aquí, la idea de camión de la segunda mesa tiene que ser mayor que el ID de camión de la primera mesa. Entonces, ¿por qué querríamos hacer esto? ¿ Para qué podemos usar esto? Bueno, hay ciertos momentos en que esta información nombra para ser dada a conocer. Bueno, por ejemplo, digamos que queremos
averiguar qué pistas se compran a menudo juntos o si alguien compra un camión, cuáles son la tiza tal vez también como algunos. Lo que podemos hacer es darle algunos de estos nombres de tabla, un alias para que podamos referenciarlo mejor. Y tampoco necesitamos todos los datos aquí. Entonces lo que queríamos seleccionar ya que queremos sacar el ID del camión de nuestra tabla de líneas de factura. El primero aquí podemos llamar a esto como pista base, tal vez el tipo de pista de línea base que se compra. Y también queremos la información de identificación del camión de la segunda tabla. Y este puede ser el camión adicional, y también necesitamos la palabra clave como aquí. Entonces si le echamos un vistazo a esto, ahora, tenemos este camión, fue comprado y también se compró esta pista. Tenemos esta pista se compró y este camión también se compró con ella. Y esta camioneta fue comprada y esta pista también se compró con ella. Por lo que ahora tenemos información sobre. Una pista que fue Bob, así
como otra que fue comprada con la misma pista. Entonces digamos que queremos averiguar qué pistas se compran a menudo con la camioneta ID seis. Entonces si vamos a la tabla de pistas aquí, solo tipo de hacer esta búsqueda manualmente. Está bien. Camión ID seis corresponde ponerte el dedo encima, ese camión. Entonces digamos que queremos encontrar donde queremos saber si alguien compra esta pista, ¿cuáles son otras pistas que les pueden gustar? O simplemente de manera más general, ¿cuáles son otras pistas que se han comprado en el mismo tipo de factura porque si alguien compra este camión y también compra otro camión, es probable que vayan a ser no como el otro pistas a. Entonces si alguien quiere comprar este camión, tal vez como una primera cosa en la que podamos pensar es en qué otros camiones a la gente que ya compró esta pista, qué otros camiones que también compran. Porque tal vez alguien que compra este camión también puede estar interesado en las cosas que otras personas han comprado. Y así podemos usar este resultado aquí para obtener muy rápidamente esa información usando un grupo por declaración. Porque podemos decir, está bien, agrupemos por nuestra pista de bajo. Y también queremos agrupar por después son pista adicional. Y ahora también queremos usar una agregación y queremos
contar el número de ocurrencias Como. Y podemos llamar a esta compra emparejada tal vez. Y entonces ordenemos todo por las compras emparejadas en orden descendente para solo obtener una salida de mesa aquí de uno este camión fue comprado. Y cuando se compró otro camión con él, ¿Con qué frecuencia se compraron juntos estas pistas? Entonces sigamos adelante y ejecutemos esto. Y podemos ver aquí, por ejemplo, cuando se compró el camión 1412 de lo que eran dos veces donde también se compró el camión 1424 con él. Y podemos ver en este caso el tipo de compras pareadas son, son bastante bajas. Pero eso también es una especie de limitación de apenas cuántas pistas tenemos disponibles, así
como cuántas facturas tenemos en nuestros datos y a medida crece
el número de facturas en nuestra tabla de líneas de factura aquí. Eso significa que tendremos más compras, más información sobre compras, y obtendremos más información sobre pistas que a menudo se compran juntas. Y así podemos esperar que estos números aquí también crezcan. Por supuesto, también podemos ordenar en el otro orden para ver, vale,
bueno, ya que nuestro valor máximo es de dos, la única otra opción que tenemos es tener un valor de uno. Pero se puede ver el enfoque que podemos tomar con esto es que podemos unir una mesa sobre sí mismos. Y por lo general queremos usar condiciones adicionales en los empleos. Ahora no sólo necesitamos usar condiciones adicionales en las autoincorporaciones. También por supuesto tenemos la opción de usar condiciones
adicionales cuando estamos haciendo otro tipo de combinaciones. Es justo cuando estamos haciendo autocombinaciones, probablemente muy probablemente
queramos usar condiciones
adicionales o simplemente para hacer algún filtrado extra. Porque si estás uniendo toda la información de la mesa sobre sí mismo, nuevo, el tamaño de tu mesa va a crecer mucho. Entonces para asegurarte de que estás reduciendo esto y realmente solo escogiendo la información que necesitas. Probablemente quieras poner en condiciones adicionales a esta declaración aquí sobre la unión que está pasando arriba. Y así en este caso, por ejemplo, pudimos usar el auto join para obtener rápidamente al
menos alguna información superficial sobre, ya sabes, si si se compró un camión, qué otras pistas también se compraron y ¿con qué frecuencia se compraron juntos estas pistas?
39. 37UnionsHB: Entonces ya hemos visto uniones ahora, pero también hay otros casos en los
que quizá queramos unir información sobre tablas juntas, pero en realidad no queremos unirlas horizontalmente, sino que más bien queremos apilar verticalmente. Y estos pueden aparecer, por ejemplo, si tienes varias tablas ese tipo de hacer un seguimiento de lo mismo, pero la información se divide en varias tablas solo para
evitar que cualquier tabla individual crezca tal vez demasiado grande. O tienes diferentes tablas, cada una de ellas un poco representando datos de un día individual. Y desea unir toda esta información en una sola tabla para que realmente pueda ejecutar una consulta en la tabla completa. Entonces, ¿cómo se puede hacer esto? Bueno, primero que nada creemos nuestros dos subconjunto de tablas para que podamos unirlas. Y vamos a utilizar la declaración create table. Y vamos a llamar a esta tabla pista parte uno. Y vamos a crear esto como resultado de la siguiente consulta. Vamos a seleccionar todo de la tabla de vías, pero sólo donde el ID del camión sea menor o igual al 2000. Pongamos un punto y coma aquí para una especie de buena práctica. Y sigamos adelante y ejecutemos esto y echemos un vistazo a nuestra base de datos ahora. Entonces entrando en nuestros esquemas en una mesa aquí. Entonces tenemos nuestra única mesa, ese camión, uno, que contiene toda la información de nuestro tractable, pero sólo los dos primeros mil camiones. Y luego vamos a crear un segundo camión de mesa Parte 2, donde toda la información y donde el camión ID MOOC de la mesa de camiones es mayor a 2000. Por lo que básicamente estamos dividiendo aquí nuestra tabla de vías, que recordamos de antes, contiene alrededor de 3,500 filas en dos mesas más pequeñas, camión Parte 1 y camión estacionado también. Como podemos ver, si acabamos de abrir este aquí, podemos ver que arrancamos camión ID 2001. Entonces, ¿cómo podemos unir estas informaciones juntas? Porque tal vez queremos usar el resultado de todas nuestras pistas porque lo necesitamos para algo. A lo mejor, ya sabes, si queremos hacer un join en todas nuestras tizas, primero
necesitamos poder unir o diferentes mesas
juntas para que realmente tengamos toda
la información sobre todas las pláticas que tenemos, más bien que usar una tabla más pequeña que solo contiene un subconjunto de todos los datos que tenemos. Entonces para hacer esto, podemos simplemente, en primer lugar, sólo un poco esqueleto del escritor la declaración selecta aquí, vamos a seleccionar todo. Empecemos con camión Parte uno y hacia aquí ahora queremos agregar en la información del camión Parte 2. Entonces para hacer eso, vamos a usar una declaración sindical aquí. Y luego vamos a tener otra declaración selecta en la que de nuevo sólo vamos a seleccionar todo. Ahora vamos a decir seleccionar todo de la pista Parte 2. Entonces si ejecutamos esto, ahora
estamos ejecutando todo el asunto y poniendo un punto y coma aquí también por sólo una buena práctica. Entonces vamos a tener toda nuestra información de las dos vías. Estamos seleccionando todo desde camión Parte 1. Estamos seleccionando todo de la pista Parte 2. Y esta declaración sindical aquí significa que esta información, o que estos dos resultados se van a unir verticalmente apilados. Entonces en lugar de tener el tipo de uniones
horizontales que vimos cuando usamos las declaraciones conjuntas. Y en cambio el sindicato lo es, vamos a utilizar los resultados de aquí. Y sólo vamos a sumar al fondo también los resultados que tenemos desde aquí. Y así de esta manera, podemos usar las declaraciones sindicales para luego unir múltiples mesas. E incluso podemos extender esto. En este caso, sólo tenemos dos mesas, pero finjamos que tenemos otra mesa para poder hacer otra unión. Y digamos que queremos volver a seleccionar todo de nuevo de la parte 2 de la pista de Luke. Y sólo podemos volver a ejecutar esto. Y podemos ver que aún corre. Entonces si tuviéramos múltiples tablas aquí, solo
podríamos hacer múltiples declaraciones sindicales donde estamos seleccionando la información que queremos de la tabla apropiada. Y luego usando la declaración sindical aquí para especie de pegarla, uno
encima del otro para que el resultado final, vaya a ser la tabla final que realmente queremos que contenga todo el tipo de datos unidos. Entonces nuevamente, en los casos donde en tus datos y tal vez divididos en varias tablas diferentes, puedes usar las declaraciones sindicales para unir esa información de todas las tablas juntas para que lo tengas todo en un solo lugar para que cuando estés ejecutando su consulta, puede ejecutarla en todas las tablas. Son todos los datos de las tablas separadas unidas, apiladas verticalmente una encima de la otra. En lugar de tener que consultar cada subtabla individualmente y luego tratar de unirse a los resultados más adelante. Ahora si queremos volver a deshacernos de las dos mesas, recuerda todo lo que tenemos que hacer, sólo
tienes que decir drop table. Y vamos a dejar caer nuestra camioneta Parte 1 y correr esto. Y luego también vamos a soltar nuestro tronco parte dos y ejecutar esto de nuevo ahora tenemos una especie de base de datos limpia porque no necesitamos dividir nuestra tabla de temas en dos pistas separadas. Por lo que podemos usar estos o podemos usarlos para el ejemplo de la Unión. Pero entonces también es bueno como limpiar de nuevo contra eso. Aquí no tenemos un montón de desorden en nuestra base de datos.
40. Subconsultas: Todo bien. En esta lección, vamos a
repasar algo realmente genial que realmente te
brinda
mucha flexibilidad en cuanto a
las consultas que
escribes porque te
permite básicamente anidar
diferentes resultados. Lo que vamos a
aprender en esta lección es
algo que
se llama subconsultas. Ahora, las ideas, y
vamos por ejemplo, volvamos a nuestra tabla de líneas de
factura, ya
podemos escribir una consulta SQL
donde solo, por ejemplo,
agrupamos por el ID de factura, y luego solo podemos contar
el número de ocurrencias. Podemos obtener un resultado
que nos diga cuántas compras se
hicieron con cada factura. Sigamos adelante y solo
escribamos esa consulta muy rápido. Vamos a tener primero nuestra sentencia SQL
esqueleto. Vamos a seleccionar de
la tabla de líneas de factura, y limitemos los resultados a cinco por ahora hasta que tengamos
confianza en nuestra consulta. A partir de aquí, vamos a
seleccionar el ID de factura. Ahora también queremos
ejecutar una agregación, y solo queremos contar el número de artículos que
tenemos en el ID de factura,
y para ello, también necesitamos un grupo por estado de cuenta y necesitamos agruparnos por el ID de factura. Si ejecutamos esto y vamos
a darle a esto un alias como número de ítems. Si estás en esto,
podemos ver aquí, Factura ID uno, por ejemplo, tiene dos artículos comprados en ella. Factura ID dos tiene cuatro artículos. La identificación de factura tres tiene seis artículos, y puede quitar esto
y echar un vistazo. Aquí podemos ver que este es
nuestro dato se ve como aquí. Por supuesto, también podemos
pedirlo, por ejemplo, por el número de
pedido por el número de artículos tal vez en Un pedido de envío. Podemos ver aquí todas estas facturas de
compra un artículo, y si pasamos por
más abajo, ahora tenemos las dos
columnas de artículos, y así sucesivamente. Ahora tenemos estos resultados. Pero, ¿y si ahora queremos saber cuántas facturas tuvieron compras de
dos artículos? Básicamente, hemos corrido
esta agregación, y ahora queremos
usar el resultado de esta agregación o tal vez
hemos realizado otra consulta, y queremos usar el resultado de esa consulta como nuestro
punto de partida para la siguiente consulta. El problema es que, en este caso, no
podemos usar realmente hay
un error tipográfico aquí por cierto, realmente no
podemos usar esta columna
porque esta columna solo existe una vez finalizada la
consulta Realmente no podemos hacer
nada más con él. No podemos ejecutar ninguna
agregación adicional por el número de elementos porque la columna
en sí no existe todavía. Sólo existe después de
que ejecutamos esta consulta. Entonces, ¿cómo podemos entonces usar los resultados de esto
y básicamente continuar? Porque a veces las consultas complican
más y
quieres ejecutar una parte del
procesamiento y sobre ese resultado, entonces
quieres seguir haciendo
otra cosa. A lo mejor quieres
hacer algún procesamiento. Sobre el resultado, se quiere
hacer entonces alguna agregación. En ese resultado, entonces quieres
hacer alguna agregación adicional, pero ahora basado en un
marco de referencia diferente porque ahora tienes diferentes columnas que tal vez representen resultados
agregados. Ahora bien, para hacer esto, podemos usar
algo llamado sub consultas. Lo que es una subconsulta es
básicamente una forma de decir, usemos el resultado de una consulta en
lugar de una tabla específica. La forma en que se
ve una sub consulta es que tenemos
una sentencia select, y luego tenemos
una declaración firme, igual que antes, Pero en vez
de tener una tabla aquí, en cambio
tenemos una consulta. Entonces al final de
esto, también tenemos que
agregar un nombre para una sub consulta. Por ejemplo, podemos simplemente
llamar a este sub para subquery. Podemos reconocer
el mismo formato. Tenemos una sentencia select, luego tenemos la F. Pero en lugar de tener
un nombre de tabla aquí, en cambio
tenemos una consulta completa. Lo que estamos seleccionando
de aquí es el resultado de
toda esta consulta aquí. Entonces también le estamos dando un alias a
esto y en realidad
tenemos que darle un alias a
nuestras subconsultas De lo contrario, vamos
a tener problemas. Le estamos dando un alias, llamándolo sub para que
podamos referirlo más adelante. Si ejecutamos esto, vamos a obtener el mismo resultado porque todo lo que estamos
haciendo ahora mismo es simplemente seleccionar de entre los resultados, seleccionar todas las columnas
del resultado de las subconsultas Pero claro,
ahora podemos hacer cosas extra. Ahora, por ejemplo, podemos
acceder al número de ítems. También podemos acceder
al ID de factura
porque ambos
fueron devueltos de nuestra
consulta dentro de aquí, de nuestra sub consulta. Agrupemos ahora por el
número de artículos y contemos cuántas facturas habían caído básicamente en cada una
de estas categorías. Así que ahora vamos a
mostrar el número de ítems y no
necesitamos hacerlo si
solo tenemos una subconsulta,
pero es una buena práctica
hacer referencia con la subconsulta de la que
estamos tomando esto porque si tenemos
múltiples subconsultas,
entonces podemos tener nombres de columna
duplicados Al igual que cuando
lo hacemos cuando estamos haciendo combinaciones o algo así y
tenemos que hacer referencia o preferiríamos hacer referencia a la tabla apropiada para asegurarnos de que no
haya confusión. Del mismo modo, cuando estamos
usando subconsultas o generalmente cuando tenemos
alias, por ejemplo, también solo para tablas,
es bueno usar
esos nombres para asegurarnos de que
estamos haciendo referencia a los Estamos seleccionando el número
de líneas de nuestra subconsulta. Ahora también queremos volver a ejecutar
una agregación. Simplemente podemos hacer el conteo
uno, en la parte inferior aquí, ahora
vamos a agrupar
por el número de artículos. Y vamos a ordenar por aquí otra vez. Y aquí queremos ordenar por, y tal vez deberíamos
darle primero a estos nals. Esto aquí, podemos decir,
número de facturas. Ahora ordenemos por el número de facturas
en un pedido de envío. Realmente no tiene
sentido tener el orden por declaración aquí
porque en este caso, no
estamos usando el
resultado de la orden por. Solo para hacer las cosas
más eficientes, podemos simplemente sacar el
orden por declaración porque no lo estamos
usando de ninguna manera, y solo estamos cambiando
el orden más adelante. Podemos sacarlo
aquí porque
no lo estamos usando en algunos casos, es posible
que en realidad estés
usando el pedido. Caso, puedes guardarlo
en la subconsulta. Pero en este caso, no estamos usando el pedido, así que
vamos a sacarlo. También voy a
agregar alguna sangría aquí solo para mostrar que todo
esto es parte de la misma
subconsulta para que sea más fácil de ver Si ejecutamos esto ahora, y sigamos adelante
y desplazemos hacia arriba, para que podamos ver, tenemos 59 facturas donde había
nueve artículos comprados cada uno. 59 facturas donde había
cuatro artículos comprados cada una. En realidad, tenemos
muchos 59 casos probablemente porque este es
el conjunto de datos de práctica. Entonces tenemos 117 facturas, donde había dos
artículos comprados cada uno. Podemos ver ahora podemos
usar subconsultas para usar el resultado de una consulta como punto de partida
para la siguiente consulta sub consultas son muy
agradables porque nos
permite
pasar esos problemas. Donde solo tenemos algunos resultados y queremos
seguir usándolos, pero no podemos acceder a las columnas
porque
aún no existen porque solo se
crean después de ejecutar la consulta. Por lo tanto, hay muchos casos que vas a
encontrar donde vas a querer usar una sub consulta para que
puedas continuar usando
los resultados
de la consulta anterior. Ahora bien, en este caso,
aunque
devolvamos el ID de factura
en nuestro estado de cuenta aquí, realidad no lo hacemos
uso aquí arriba. Solo para mantener las cosas limpias, incluso
podemos simplemente
eliminarlo porque realmente no
lo
estamos usando para nada. En este caso, podemos simplemente
quitar el ID de factura para mantener
limpia nuestra subconsulta porque de nuevo, no
necesitamos hacer uso de ella, así que no tiene sentido
devolverla
porque no va
a agregar mucho valor Porque todo lo que estamos usando
es el número de artículos. Y ahora que tenemos
el número de ítems, que es el resultado
de una agregación, ahora
podemos usar esa
columna resultante, y por ejemplo, volver a
ejecutar una agregación sobre ella, ahora agrupando por los valores
en esta columna en su lugar.
41. 39VentanaFuncionesy 39WindowFunctionsAndAliasesHB: Ahora ya hemos visto que podemos hacer mucho con SQL, pero hay algunas cosas que aún están en Insertar. Y una de estas cosas, por ejemplo, es llevar las agregaciones un paso más allá. Porque actualmente cuando estamos ejecutando agregaciones, nos enfocamos principalmente en obtener agregados los resultados sobre toda la tabla. Pero a veces no queremos resultados agregados sobre toda la tabla, sino que más bien nos gustaría mantener todas las filas y sin embargo poder tener resultados agregados
intermedios o resultados agregados que estén ejecutando promedios o algo por el estilo. Entonces sigamos adelante y echemos un vistazo a cómo podemos resolver algunos de estos problemas. Entonces, antes que nada, solo escribamos aquí nuestra declaración SQL esqueleto. Y vamos a usar la tabla de temas aquí. Entonces sigamos adelante y solo seleccionemos todo de la mesa de camiones ahora mismo. Y en primer lugar, sólo limiten nuestros resultados. Si ejecutamos esto, podemos ver aquí, De acuerdo, exactamente lo que esperamos. Entonces, ¿qué pasa si, por ejemplo, queremos ver una agregación corrida sobre los diferentes álbumes que tenemos aquí. Y queremos saber cuál es el tiempo de ejecución para cada pista que pasa por el disco. O qué pasa si queremos conservar la información sobre las filas pero aún así tener acceso al valor agregado. ¿ Cómo podemos hacer eso? Actualmente no podemos. Entonces vamos a responder primero a la segunda pregunta, que es que queremos mantener información sobre todas las filas, pero también queremos tener acceso al valor agregado. Entonces lo que vamos a hacer es sólo ir a seleccionar todo para que podamos tener esta información. Pero ahora también queremos poder acceder a esta suma corriente. Entonces básicamente lo que queremos hacer es sumar a lo largo los milisegundos aquí para que estemos haciendo un seguimiento del tiempo de cada canción a medida que estamos pasando por el disco. Por lo que queremos sumar sobre la tabla de milisegundos aquí, o más bien sobre la columna de milisegundos. Pero si hacemos esto, entonces tenemos que usar un grupo por declaración. Pero hay otra forma en que realmente podemos expandirnos en la declaración,
es decir, usando funciones de ventana. Entonces lo que podemos hacer es que podemos escuchar por alto vez y luego espaciar y abrir y cerrar paréntesis. Y dentro de la declaración, podemos entonces crear particiones haciendo particiones particionadas por. Y acabemos primero la declaración y luego como que regresemos y lo miremos. Y vamos a particionar por la idea del álbum. Entonces lo que esto significa es que estamos seleccionando todas las columnas todavía, y vamos a hacer una suma sobre la columna de milisegundos, pero no estamos usando el grupo por declaración en su lugar, hay otra opción que tenemos disponible la cual tiene esta exageración aquí. Y así dentro de esta exageración, podemos entonces crear particiones, que es similar a lo que haríamos en la cláusula BY del grupo. Pero aquí solo estamos definiendo cómo queremos dividir nuestros datos. Y en lugar de obtener resultados agregados devueltos para cada columna y tener que
incluir esos como un poco el resultado basado en lo que
tenemos en el grupo BY, simplemente podemos tomar todas nuestras columnas y especie de mantener todos nuestros registros. Pero podemos tener una columna extra que o tiene una agregación en ejecución también son solo una agregación basada en el grupo. Ahora la forma en que funciona esta agregación depende de lo que crece se va a seleccionar. Entonces en este caso, si estamos usando la partición POR lo que va a pasar es que vamos a dividir todos nuestros datos en diferentes particiones basadas en cada ID de álbum aquí. Y para cada partición donde Lincoln un ejecutar esta agregación, vamos a ejecutarla en este caso sobre cada partición. Entonces si solo nos damos un alias, podemos llamar a este álbum de longitud, duración del
álbum o lo que quieras. Y solo, vamos a ejecutar esto y echar un vistazo a la salida. Y también llevemos o limitemos la declaración aquí. Entonces corriendo esto y luego bajando a nuestra salida aquí abajo, moviéndonos todo el camino a la derecha, tenemos aquí nuestra longitud de álbum. Y podemos ver si nos desplazamos hacia abajo, esto va a diferir en base a qué ID de álbum tenemos. Por lo que tenemos una longitud de álbum única para cada ID de álbum. Pero lo interesante en la forma en que esto difiere del grupo por declaración es que todavía mantenemos en todas las filas individuales. Todavía tenemos toda la información sobre las filas individuales. También tenemos acceso al valor agregado. Y podemos ver que se diferencian a través de las diferentes particiones aquí. Por lo que tenemos nuestro álbum ID uno, y se puede ver en este caso, todos estos valores son iguales. Tenemos nuestro álbum ID 2 aquí. Simplemente tenemos este valor único. Tenemos un E3 de mente abierta aquí de nuevo, los valores van a ser los mismos y para cuatro y así sucesivamente. Entonces ahora tenemos el agregado, o más bien la suma sobre esta columna de milisegundos para cada ID de álbum. Entonces dividiendo todo por los diferentes identificadores de álbum y sumando a lo largo de los milisegundos. Pero porque estamos usando esta exageración y estamos usando particiones aquí arriba. En lugar de usar el grupo por declaración, ahora
tenemos acceso a los robots individuales también. Entonces por supuesto, esto es genial cuando también necesitas tener acceso a estos otros datos. Pero otras veces el grupo por declaración puede ser mejor porque vas a conseguir una tabla mucho más pequeña y principalmente
vas a estar obteniendo los resultados que necesitas si no necesitas tener acceso a los otros datos aquí. Por lo tanto, de nuevo, tipo de depende de tu caso de uso y qué
es exactamente lo que necesitas de estos resultados de agregación. Ahora actualmente son valor agregado aquí es el mismo en todas las columnas, pero incluso eso no necesita quedarse así. Ahora, la forma en que funciona esta agregación, nuevo, depende de cómo estemos dividiendo nuestros datos aquí. Si solo estamos usando la sentencia partición
BY, entonces lo que sucede es para cada partición, se incluyen
todas las filas. Pero en realidad también podemos añadir otra cláusula aquí,
a saber, el orden por. Y este es el mismo orden por el que hemos visto antes, pero internamente por cada split que estamos haciendo, en este caso por el ID del álbum, también
podemos ordenar los resultados dentro de cada split. Y ordenemos, por ejemplo, por la columna de nombre. Y entonces qué pasa en este caso si lo
ejecutamos, en realidad vamos a conseguir diferentes valores aquí, incluso dentro del mismo ID de álbum. Y entonces lo que se puede ver desde aquí, en realidad
estamos consiguiendo un total corriendo. Entonces en este caso estamos consiguiendo un total corrido de hasta esta canción. Esto es cuanto tiempo, ambas de estas canciones, y luego aquí arriba son los tres de estos sonidos juntos. Aquí Son las cuatro de las canciones. Y luego una vez que lleguemos a un nuevo disco, el contador se restablece. Y la razón por la que esto es diferente es porque cuando estamos usando la
cláusula orden por en lugar de que todas las filas para cada partición se consideren juntas, solo
consideramos las filas que suben e incluyen el valor por el que estamos ordenando. Ahora bien, si hay duplicados, todos esos duplicados van a ser considerados. Entonces si tenemos, por ejemplo, el nombre de la segunda aquí y la tercera canción siendo la misma. Entonces el valor agregado que vamos a conseguir aquí va a ser el mismo a través de los dos porque estamos ordenando por y hay un duplicado en el nombre, así que va a ser lo mismo. Y también va a ser igual a los tres primeros básicamente porque el primero no será único en el segundo o tercero sería un duplicado. Y así el valor que obtenemos aquí sería el de los tres. Entonces sólo un tipo de cosas para notar sobre cómo se comporta este comportamiento o cómo se comporta esto. Entonces sí, como podemos ver ahora, podemos tener una forma diferente de acercarnos a la agregación. Y uno de ellos es el GroupBy y el otro está usando esta exageración. Y entonces podemos particionar por diferentes columnas aquí. Y si sólo estamos usando la partición
BY, entonces los valores agregados que vamos a obtener van a estar básicamente dentro de cada partición. Pero si nosotros, si agregamos un orden por cláusula dos, entonces nuestra agregación ya no va a ser una dentro de cada partición, sino que va a ser una agregación en ejecución basada en el orden que aquí hemos definido. Ahora bien, ¿y si queremos hacer algunas agregaciones adicionales? Entonces, por ejemplo, tenemos la suma, pero tal vez también queremos hacer como un conteo corrido porque es una agregación adicional y eso podemos hacer. Por lo que también podemos hacer, por ejemplo, sólo para dar cuenta de uno aquí. Y tal vez también queremos simplemente hacer un seguimiento de la longitud media de la canción dos. Por lo que también queremos hacer un promedio de la columna de milisegundos tal vez. Entonces aquí tenemos nuestro recuento de canciones del álbum, y aquí tenemos nuestra longitud promedio del álbum. Entonces si seguimos adelante y corremos esto de nuevo, y ahora podemos desplazarnos un poco más y mirar los resultados. Entonces de nuevo aquí para cada uno de estos, vamos a tener una agregación corriendo porque estamos usando la cláusula orden por. Aquí. Vamos a tener un total corriendo, o estás ejecutando algunos de los milisegundos. Aquí vamos a tener un conteo corrido. Y aquí vamos a tener un promedio corriente en todos los milisegundos. Entonces en este caso podemos ver sólo consideramos un valor, por
lo que tenemos aquí. En este caso, va a ser el promedio de los dos primeros, que es este resultado aquí. Aquí va a ser el promedio de los tres primeros y así sucesivamente. Para que puedas ver podemos usar las diferentes funciones de agregación y aún así utilizarlas sobre estas diferentes ventanas. Pero en este caso, no
es ideal repetir siempre las declaraciones aquí. Idealmente, podríamos tener una taquigrafía para esto para que no
solo estemos repitiendo esto porque lo hace más difícil, hace
que sea más difícil de leer. Pero también si quieres cambiar algo tienes que pasar y
tienes que cambiarlo y cada lugar. Y en realidad también podemos crear alias para estas ventanas aquí. Entonces para hacer eso, vamos a bajar aquí y vamos a definir ventana. Entonces le vamos a dar un nombre de alias o simplemente le vamos a dar un nombre para que podamos escuchar decir álbum, nombre, split por ejemplo. Y luego vamos a usar declaración. Y entonces podemos tomar aquí la definición de esta ventana. Y lo vamos a poner aquí abajo. Y entonces en su lugar, podemos usar este alias que ahora hemos creado para esta ventana aquí en su lugar. Y así con el uso de esto, vamos a estar haciendo referencia a esto. Y entonces podemos ponerlo aquí también. Y también podemos ponerlo aquí. Ahora de nuevo, esto tiene la ventaja de que por un lado, esto se vuelve más fácil de leer. Pero por otro lado, esto también es mucho más limpio para escribir porque si
queremos hacer un cambio a nuestra ventana aquí, entonces solo podemos hacer el cambio uno y se propaga a todos los diferentes. Agregación es que estamos haciendo aquí son todos los diferentes usos. tanto que si solo copiamos pegar todo lo que cada vez que
hacemos un cambio, tenemos que hacer ese cambio y cada columna diferente, que por supuesto no es tan agradable. Entonces vamos a ejecutar esto y podemos ver obviamente
vamos a obtener los mismos resultados porque nada más ha cambiado. Acabamos de introducir un alias. Pero ahora si hacemos algo más, ejemplo, intentemos particionar por ID de álbum, pero también particionando quizá por el ID de género como segunda capa de partición. Ahora es muy probable que cada álbum vaya a tener el mismo ID de género. Pero tal vez haya algunos casos en los que un disco tiene diferentes temas que tienen diferentes géneros. Es posible. No muy probable en muchos casos, pero es posible. Entonces en aquellos casos en los que hay más de un género, entonces vamos a tener una división pasando ahí. Y si solo hay un género dentro, entonces aunque estemos dividiendo por el ID de género, porque solo hay un género o resultados, no vamos a cambiar. Entonces al igual que tenemos en el grupo por declaración, también
podemos agregar adicional aquí. Entonces no es sólo, no tiene que ser sólo una columna que estamos particionando cinco, en realidad
podríamos particionar por varios. Lo importante a tener en cuenta con esto es que primero hacemos esta partición, luego hacemos esta partición. Y si tenemos más que, los
haríamos después. Por lo que el id de género sólo se dividiría dentro de cada grupo de ID de álbum. Entonces solo una cosa importante a tener en cuenta. Pero ahora podemos volver a ejecutar esto y se puede ver que porque no estamos usando un alias, todos estos cambios se aplican automáticamente a todos los sentidos donde usamos el alias. tanto que si sólo usamos el valor pegado de copia, habríamos tenido que hacer este cambio tres veces, lo que por un lado es molesto. Pero por otro lado, también puedes olvidarte de hacer el cambio en alguna parte. Y así entonces tus resultados van a estar equivocados, Principalmente porque no aplicaste el cambio en todas partes y eso son errores comunes que suceden. Entonces de esta manera, puedes acelerar las cosas, facilitar la lectura de las cosas y preocuparte menos por tener este tipo de errores. Ahora en cuanto a dónde iría esta definición en nuestro formato SQL completo. Entonces esto va a ir si tenemos una declaración donde y después vamos a tener la ventana, pero también va a suceder antes de la orden POR, así que digamos que queremos decir lo que sea y no vamos a hacer ningún otro filtrado. Sólo vamos a decir que estamos rastreando ID es mayor o igual a uno. Y luego aquí abajo vamos a tener nuestro OrderBy. Y sólo ordenemos todo por ID de álbum, lo que probablemente ya lo es. Pero podemos simplemente seguir adelante y hacerlo de nuevo y simplemente decir aquí un orden ascendente. Y aquí es donde debe ir la definición de alias de ventana. Tomamos esto y lo movemos aquí arriba y ejecutamos esto. Entonces podemos ver aquí vamos a obtener un error de sintaxis porque de nuevo, necesitamos tener las cosas en un orden específico y así no pertenece ahí. Por lo que tenemos que llevárnoslo de vuelta aquí. Y luego si lo volvemos a ejecutar, todo está bien. Ahora, podemos ver que aquí usamos el ascendente. Por supuesto, si estamos usando la cláusula orden por y aquí están lo mismo sigue aplicándose. También podemos definir un domingo aquí, o también podemos usar el descendente. Y al igual que podríamos agregar múltiples cosas aquí en la partición, también
podemos agregar múltiples cosas aquí en el OrderBy para resolver potencialmente lazos. Entonces, por ejemplo, podemos ordenar primero por el nombre y luego tal vez queramos ordenar por otra cosa, por ejemplo, los bytes. Y así en esos casos, y de nuevo, aquí no vamos a estar haciendo nombre ascendente y blancos descendentes ya que necesitamos suministrar el formulario de pedido para cada columna que estamos usando. De lo contrario sólo se va a asumir ascendente. Entonces podemos ver que tenemos mucha flexibilidad con esto también. Pero ahora si hay un empate en la columna de nombre, lugar de que se use en la agregación para como básicamente un valor duplicado. En lugar de Skinner mira al segundo orden que
va a estar en la columna de bytes y solo tendrá un conteo duplicado y la agregación en algún lugar si el nombre y los bytes son ambos iguales. De lo contrario vamos a tener un orden adecuado en marcha. Para que podamos ver, podemos correr esto una y otra vez. Simplemente podemos ver nuestros resultados aquí. Y la tabla a continuación.
42. 40RowNumbersAndRanksHB: Ahora acabamos de ver cómo podemos usar funciones de ventana para hacer agregaciones sobre partes individuales de particiones que definimos. Pero con 10 funciones, no solo
podemos hacer agregaciones, sino que podemos hacer otras cosas como contar números de fila. Y esto también puede ser realmente útil. Entonces echemos un vistazo a cómo hacer eso ahora. Y para esto, vamos a utilizar la tabla de líneas de factura. Y lo que vamos a hacer es que vamos a hacer un yo soy tonto, poco dividido y sólo dividir todo por el precio unitario, o más bien partirlo todo por el precio unitario para que vamos a conseguir algunos valores duplicados. Y luego podemos ver cómo estas diferentes cosas lo afectan a todo. Vamos a seguir adelante y escribir son sólo seleccionar esqueleto. Vamos a escribir selecto todo de la tabla de líneas de factura, sólo poniendo un punto y coma aquí. Muy bien, entonces vamos a seleccionar todo y ahora vamos a tener nuestras funciones de ventana aquí. Entonces lo primero que quizá podamos ver es el número de fila. Así que sólo haciendo un seguimiento de, ya
sabes, el número de fila que había en cada partición. Entonces para hacer eso, en lugar de poner aquí una función de agregación, podemos poner en su lugar la función de número de fila, que no toma una entrada. Y luego vamos a tener nuestro formato de función de ventana estándar que también vimos antes, donde hacemos un sobre. Y ahora aquí definimos lo que queremos particionar POR. Entonces vamos a particionar por el precio unitario. Y también hagamos algunos pedidos. Pedimos por el ID de camión. Y esto aquí sólo podemos poner como el número de fila. Ahora para esto, definitivamente vamos a conseguir algunos valores duplicados porque por supuesto, es probable que
haya algunas compras duplicadas de seguimiento de TI. Entonces podemos ver que estamos agrupando o mejor dicho estamos particionando por el precio unitario aquí y aquí. Pedido de aves por el ID de camión dentro de cada tabique. En este caso, es probable que todo tenga un precio unitario de 0.99 dólares. Y así sólo tenemos una partición grande que tiene este ordenamiento. Y en este caso podemos ver sólo mirando los números de fila, todavía
tenemos número de fila incremental es a pesar de que aquí tenemos valores duplicados. Ahora si lo definimos más allá lo están ordenando no solo por identificación de camión, sino también por identificación de factura, entonces nuestros resultados aquí no van a
cambiar realmente sólo porque no ha cambiado mucho más. Por lo que todavía podemos hacer hacer un seguimiento del individuo surgió aquí, y todavía podemos hacer más pedidos. Pero también hay diferentes formas en que podemos contar los números de fila. Entonces en este caso, estamos dando un número de fila por cada fila que
tengamos independientemente de si hay un valor duplicado o no. Tomemos esta orden POR aquí otra vez. Pero a veces no queremos eso. En ocasiones queremos que los valores duplicados tengan el mismo número de fila. Y para ello, podemos usar una función aquí llamada rank. De nuevo, no toma ninguna entrada. Y solo para cada uno, dentro de cada partición, entonces
vamos a darle un rango a cada orden por industria que tenemos un lugar por cada entrada que tenemos. Pero el rango es diferente en que los valores duplicados, como podemos ver aquí, se les asigna el mismo número de fila. Probablemente sea mejor si actualizamos esto para clasificar. Pero el rango es de nuevo sólo una forma de número de fila. Pero para valores duplicados, van a tener el mismo rango. Entonces puedes ver aquí esto es 1, 2, y esto serían tres, pero es un duplicado porque cuando estamos ordenando por el ID del camión, estos son los mismos valores. Por lo que dentro de esta partición de un precio unitario de 0.99, los valores de ID de camión aquí son las dos filas aquí son duplicados porque de nuevo, tienen el mismo ID de camión. Entonces en este caso, son del mismo rango. Y podemos ver una vez que
avanzamos, luego vamos a 45678 y así sucesivamente hasta llegar a otro duplicado. Y luego van a conseguir el mismo rango. Pero luego seguimos contando y básicamente solo haciendo un seguimiento del número de duplicados aquí y luego seguimos contando con dónde tendríamos si estuviéramos usando los números de fila en su lugar. Ahora esto puede ser realmente agradable porque a veces no quieres
asignar números de fila son diferentes números de fila cuando hay instancias duplicadas. Y así el rango también puede ser algo muy útil de usar. Pero también hay otros casos en los que no quieres estar saltando números y no tienes tanto interesado en el número de fila absoluta en lugar del orden completo en el
que entran las cosas y solo quieres tener tipo de consistente orden consecutivo. Y lo que haces puedes usar para esto es algo llamado rango
denso o la función de rango denso. Y así si ejecutamos esto, el cambio que tenemos es más que en este caso, por ejemplo, tener un cuatro porque aquí tenemos dos dos dos dos, sólo
vamos a seguir contando desde el siguiente número consecutivo. Por lo que ya no importa es cuántos duplicados tenemos. No vamos a saltar básicamente esos muchos números, sino más bien vamos a seguir contando desde el siguiente número. Ahora de nuevo, esto es específico para cada partición que tenemos. En este caso, usar el precio unitario nos permitió crear un tabique donde podemos estar seguros de que aquí hay algunos duplicados para los identificadores de camión. Pero claro, si tienes, ya
sabes, múltiples particiones que tu rango, o en este caso en realidad va a ser el rango denso o también los números de fila. Van a ser específicos de cada partición. No van a repasar toda la mesa. Van a ser específicos de cada partición. Entonces eso es solo una cosa importante a tener en cuenta, que tu rango, tu rango denso, o incluso tu número de fila se van a restablecer y solo se van a definir dentro de cada partición se divide que tienes aquí. Ahora si quisieras encontrarlo sobre la base de datos, lo que puedes hacer es en lugar de dividir particiones por cualquier cosa, y tal vez ni siquiera tienes una columna ese tipo de tiene el mismo valor en todas partes. Simplemente puede quitar esta declaración de partición y simplemente dejar la instrucción orden BY. Y, y de esa manera nuestra función de ventana aún se va a ejecutar, pero ahora ya no estamos particionando por nada. Y así de esa manera pasamos de tener el rango o el rango denso o el número de fila específico de cada partición. Pero más bien lo tenemos para todo el conjunto de datos porque ahora ya no estamos creando una partición.
43. 41UsingotrosRowsWithde: Muy bien, así que hemos echado un vistazo a las funciones de
ventana y vimos algunas cosas geniales que podríamos hacer con ello específicamente haciendo agregaciones en ejecución son agregaciones basadas en las particiones sin sacrificar ninguna de las información que tenemos en las filas individuales. Ahora, sin embargo, en algún momento, es probable que querrás acceder a información de otras filas. Por ejemplo, tal vez quieras
saber de dos compras consecutivas o 11 de compra sucedieron cuando ocurrirá la próxima compra
o, o algo así. Actualmente la forma en que estamos haciendo uso de los datos es que cada fila es un tipo de trato individual. Y ahora mismo no hay forma de que accedamos a la información de otras vías. Entonces echemos un vistazo a eso ahora. Y vamos a utilizar la tabla de facturas para esto. Y vamos a seguir adelante y escribir nuestras declaraciones SQL esqueleto. Vamos a decir seleccionar todo de la tabla de facturas. Y solo sigamos adelante y limitemos nuestros resultados a cinco por ahora. Adelante y corre esto. Entonces estos van a ser nuestros resultados aquí. Y ahora intentemos crear una fila o fila modificadora para que con cada fila que
tenemos, tengamos la columna de fecha de factura y también tengamos algo llamado el siguiente estado, que en este momento sólo va a ser la voz de la fecha de la siguiente factura, independientemente de si es del mismo cliente o algo así. Sólo tengamos una nueva columna que nos dé la fecha de la siguiente factura. Entonces, ¿cómo podemos hacer eso? Bueno, la forma en que podemos hacer eso es otra vez, usando nuestras funciones de ventana. Pero lo que vamos a hacer aquí es que vamos a usar algo llamado Read. Ahora lo que hacemos con el plomo al poner en dos parámetros, el primero va a ser una columna de la que queremos la siguiente información. Por lo que en este caso queremos utilizar la fecha de la factura. Y en el otro parámetro que tenemos es ¿a qué tan lejos queremos ir? Entonces, por ejemplo, queremos tomar el valor de la siguiente fila. Entonces vamos a usar el plomo en la fecha de la factura y vamos a ir uno hacia adelante. Entonces por ejemplo, porque en esta fila actual y lo que va a hacer el lead es que nos va a permitir
acceder al valor desde una fila más allá en la fecha de la factura. Si hacemos dos, si fuéramos esta fila, estaríamos buscando filas más allá. Entonces así es como podemos definir esto aquí. ¿ Cuántas filas queremos ir al frente? Entonces vamos a quedarnos con uno. Ahora para completar esto, también
necesitamos definir de nuevo la partición que queremos
repasar específicamente usando las funciones de ventana. Pero como también vimos anteriormente, en realidad no necesitamos definir la partición si no queremos. Entonces si solo quieres usar la mesa completa, que vamos a hacer por ahora. Simplemente vamos a utilizar la cláusula de pedido BY y vamos a pedir por fecha de factura. Por lo que todo se va a pedir por fecha de factura. Y por cada fila sólo vamos a tener la siguiente fecha de factura. Y vamos a seguir adelante y dar a esta columna alias, llamándolo próxima fecha de factura. Y si seguimos adelante y ejecutamos esto, y sigamos adelante y echemos un vistazo. Nuestra salida. Aquí tenemos la siguiente fecha de factura, y aquí tenemos la fecha de factura actual. Y podemos ver que este valor es justo igual a lo que tenemos para este valor aquí. Por lo que puedes ver que siempre estamos tomando el siguiente valor de la columna de fecha de factura y tenerlo en nuestra fila actual. Ahora por supuesto también podemos hacer más con esto. Podemos hacer algo de la aritmética. Por lo que también nos enteramos de antes. Por ejemplo, si queremos conseguir la diferencia horaria a la siguiente factura, entonces solo tomemos nuestra declaración aquí, y solo copiemos todo. Ponlo aquí abajo, y actualiza el alias de columna para decir tiempo a la siguiente factura. Y lo que vamos a hacer es tomar nuestra fecha de factura y vamos a ver esto. Vamos a usar esta función de plomo aquí para obtener el siguiente valor. Y luego de ella, sólo podemos restar la fecha actual de la factura. Entonces si seguimos adelante y ejecutamos esto y obtenemos una columna extra aquí. Y ahora podemos ver, vale, ¿cuál es la diferencia horaria a la siguiente fecha de factura? Entonces en este caso tenemos una diferencia horaria de un día, que también podemos ver aquí. Y en realidad solo seleccionemos aquí
la columna de fecha de factura para que podamos comparar todo lado. Entonces corriendo esto otra vez. Entonces aquí obtuvimos la fecha actual de la factura, la siguiente fecha de la factura, que proviene del uso de esta función de plomo en la columna de fecha de la factura. Entonces estamos tomando el siguiente valor, ya que es el de la columna de fecha de factura que está aquí. Podemos ver que aquí las diferencias de tiempo un día entre este valor y este valor. Aquí nuevamente, la diferencia horaria es un día entre éste y éste. Aquí la diferencia horaria es de tres días entre éste y éste. Y así podemos ver, sólo estamos usando el valor de la siguiente fila. Y por supuesto podemos seguir usando nuestra aritmética aquí. Es solo importante notar el orden en que estamos usando la aritmética En eso lo estamos haciendo después de haber definido nuestra ventana aquí. Porque cuando estamos usando funciones de ventana, como el plomo aquí, por ejemplo, necesitamos asegurarnos de que el ovario. Y palabra clave viene después. Entonces tenemos que tener todo esto como una declaración de grupo. Y luego después podemos hacer, por ejemplo, el menos como lo tenemos aquí. Ahora de nuevo, no sólo necesitamos seleccionar de la siguiente columna. También podemos ir, o más bien de la siguiente fila, también
podemos ir a filas hacia adelante o simplemente cambiar esto para que sea un dos. Y si seguimos adelante y ejecutamos esto, se
puede ver aquí ahora básicamente nos estamos saltando dos gorra rho. Por lo que este valor aquí es para esta fila, dos filas más adelante. Entonces podemos ver que éste viene por aquí, esta 12 filas más allá, esta que va por aquí. Por lo que se puede ver que no sólo se limita a una fila. Podemos definir como el salto que queremos dar. Ahora bien, ¿y si queremos ir al revés? ¿ Y si en lugar de mirar la siguiente fila o al siguiente pro después de eso o después de eso o, ya
sabes, lo que sea. Y si queremos ir hacia atrás en su lugar, queremos mirar la fila anterior. Entonces lo que podemos hacer aquí es en lugar de usar el lead, la función que queremos usar aquí se llama el lag. Y aquí podemos entonces actualizar nuestro nombre y decir anterior equipo de factura. Y podemos hacer lo mismo aquí usando el LOG en lugar de la ventaja. Y vamos a conseguir lo mismo. Hagamos sólo la fila anterior en lugar de dos filas anteriores. Y vamos a conseguir lo mismo excepto en este caso, tenemos, estamos mirando la cabeza de fila en lugar de la siguiente fila. Aquí. También necesitamos actualizar esta vez desde la factura anterior. Ahora va a haber algo interesante aquí y no hemos
considerado dónde no nos hemos encontrado con el otro caso vengo de la ventaja, pero veremos cuando ejecutemos esto, el primer valor aquí va a ser nulo. Y eso es porque no hay nada antes de la primera fila. Y sucede lo mismo con la ventaja cuando llegamos a la última fila. O si tienes aquí tal vez dos o tres. Si llegamos a la segunda pérdida para el tercer último o cualquier número que tengamos aquí, fila y cada fila después de eso, vamos a tener unos valores nulos en estas columnas. Sólo porque esos valores no existen, ¿verdad? No hay, es si esta es nuestra primera fila, no
hay fila anterior a la primera fila, por lo que estos valores van a ser nulos. De igual manera, cuando llegamos a nuestra última fila, no
hay fila después de la última fila. Y así estos valores tienen que ser nulos. Entonces eso es algo que un poco viene de TI y algo de lo que estar al tanto. Pero de nuevo, aquí podemos usar la función de bloqueo junto con esta ventana que hemos definido aquí para obtener acceso a valores en las filas anteriores. Y por supuesto, no sólo necesitamos usar la fecha de la factura. Podemos usar cualquier otra columna en 1D. Simplemente podemos definir de qué columna queremos acceder al valor anterior. Cuántas filas queremos ir atrás o adelante dependiendo de si estás usando el lag o el lead. Y luego también la ventana que queremos usar. Y este caso porque no definimos una partición, solo
estamos usando todo el conjunto de datos, pero también podemos hacer esto sobre una base de partición. Entonces, por ejemplo, podríamos intentar particionar por ID de cliente. Para que puedas configurar esto. Podemos decir partición
BY, y luego vamos a usar el ID de cliente. Y entonces podemos hacer lo mismo aquí. Y en este punto, porque ya estamos usando dos y tuvimos que hacer el pegado de copia y probablemente bueno para definir un alias. Vamos a decir rápidamente ventana aquí y vamos a definir nuestra ventana o probablemente no Usar hacia afuera. Entonces solo diremos w As y pondremos esto aquí. Y ir en su lugar sobre W, donde no tenemos que lidiar con estos temas de copiar y pegar. Entonces sigamos adelante y corramos esto una vez más. Para que te veas ahora acabamos de crear un alias del que nos enteramos antes. Por lo que vamos a volver a la fila anterior. Pero en este caso hemos creado una partición por ID de cliente. Por lo que también sigamos adelante y veamos nuestra identificación de cliente. Y también podemos ver esa información para ti. Adelante y ejecuta esto, vale, así que aquí tenemos todas las facturas para ID de cliente uno. Y también es cambiar el orden de las columnas aquí solo para especie de tener cosas más fáciles de comparar. Entonces primeras ideas de vestuario, la primera columna que alguna vez podemos invertir estado así como la fecha de factura anterior y la hora desde entonces. Entonces tienes ID de cliente uno, sus compras y básicamente cada punto aquí, el tiempo a la compra anterior y cuál fue la diferencia horaria a eso. Y si eliminamos nuestra declaración de límite, entonces podemos por supuesto obtener la información. Y también para las otras particiones de clientes que tope. Se puede ver en algún momento dependiendo, ya sabes, cuántos clientes o cuántas compras tenga un cliente. A veces tener un cliente solo tiene una compra, entonces todos ellos veríamos, por ejemplo, sólo sería un nulo. En este caso, todos estos clientes tienen múltiples compras. Pero claro, si estamos creando particiones, no
es improbable que algunas de nuestras particiones solo contengan un valor de una. Pero lo importante aquí a ver también es que cuando estamos usando las particiones, de
nuevo, por la forma en que funcionan las funciones de la ventana, estamos calculando esto sobre cada ventana. Y así podemos ver que a pesar de que aquí probablemente
haya una fecha que sucedió antes de esto, porque esto es específico del grupo ID de cliente ocho. Aquí no tenemos valores ya que esta fue la fecha de la primera compra de ID de cliente ocho. Entonces otra vez, especie del mismo principio con partición que
también vimos en la agregación cuando nos enteramos de las funciones de ventana primero, que aquí nuestra función de ventana, o más bien la función que estamos aplicando sobre esta ventana, nuevo va a ser específico de cada partición. Y también va a estar bordeado por la declaración que tenemos aquí dentro.
44. 42NTilesHB: Ahora en algunos casos, posible que
queramos dividir nuestros datos en diferentes cubos e igualmente, o más bien tener datos en cubos de tamaños iguales. Entonces eso tal vez podamos hacer algún tipo de
análisis de bloque o cubo o cualquier otra aplicación para la que estamos tratando de usarlo. Entonces, ¿cómo podríamos usar SQL
para tal vez ya crea algunos cubos para nosotros que podemos usar o mejor dicho poner números a cada una de nuestras filas y básicamente dividirlos en cubos. Entonces de nuevo, podemos hacer eso usando funciones de ventana, y vamos de nuevo a usar la tabla de facturas aquí y una escritura de nuestro extracto SQL esqueleto, simplemente seleccionando todo de la columna de factura. Y sólo tienes que seguir adelante y limitar los resultados a cinco al principio. Adelante y corre esto sólo para que tengamos un resultado ya. Muy bien, Así que dividamos nuestro cubo y dos grupos de igual tamaño. Entonces, de nuevo, vamos a usar una función de ventana aquí. Lo que vamos a hacer es que la función se llama n-type, lo que nos permite definir cuántos cubos de igual tamaño queremos dividir nuestros datos en R en los que queremos asignar nuestros datos. Entonces, por ejemplo, si decimos y cinco, eso significa que lo vamos a poner en cinco cubos de igual tamaño o lo más iguales posible. Entonces echemos un vistazo a esta salida y hagamos esto en realidad. En realidad va a hacer la ventana, por qué particionar sobre ID del cliente para asegurarnos de que realmente podemos ver las diferencias. Entonces como estamos usando una función de ventana aquí, vamos a tener que ir a usar la palabra clave. Ahora vamos a particionar por el ID de cliente. Y vamos también una vez más, ordenemos por fecha. Y vamos a tener una fecha de factura. Y vamos a darle a esto un alias o decimos número de cubo. Y también quitemos aquí nuestra declaración de límites. Y, uh, adelante y corre esto. Muy bien, así que desplazando todo el camino hacia la derecha donde va a estar nuestra última columna. Tenemos aquí nuestro número de cubo. Y en realidad sólo tomemos un número reducido de columnas aquí ya que no las vamos a usar de todos modos. Entonces tomaremos el ID de cliente, tomaremos fecha de
la factura porque eso es por lo que estamos particionando así como
por lo que estamos ordenando y ejecutamos eso una vez más. Por lo que tenemos el ID de cliente uno aquí. Y podemos ver que nuestras compras aquí
se han dividido básicamente en cubos lo más iguales posible. No somos capaces de meternos en todo. Pero podemos ver aquí el primer año que he estado agrupado en cubo 1, segundo 2, o número 3, y 4 de cubo congruente a la siguiente 1345. Por lo que tratando de llegar lo más igualitario posible, pero no hay una distribución perfectamente de equilibrio. Entonces podemos llegar hasta aquí. Y luego pasando al siguiente cubo para ID de cliente 2. De nuevo, tenemos los altibajos en los diferentes cubos. Y este caso en realidad tenemos el mismo número de compras para cliente con id1 y cliente con id2. Entonces en este caso, sólo porque estamos usando un conjunto de datos de práctica, parece que todos los clientes en realidad tienen un número muy igual de compras. Entonces todas las distribuciones de cubo que estamos consiguiendo aquí, vas a ser lo mismo a través de los diferentes ID de clientes. Nuevamente, sólo porque cada cliente en realidad tiene un número muy similar de compras, si no idéntico número de compras. Pero podemos volver a jugar aquí con nuestros tamaños de cubo. Por ejemplo, si usamos siete, que es el número de compras que cada cliente aquí realmente tiene. Podemos ver que nuestros cubos aquí vamos a ser ahora iguales uno y cada uno para en su lugar usar tres. Vamos a esperar tres en los primeros 12 en los otros. Por lo que podemos usar el azulejo n aquí para definir cuántos cubos de, idealmente son aproximadamente igual tamaño en el que queremos dividir nuestros datos. Y sólo va a poner esos dentro. Y otra vez con el primero tipo de conseguir más valores el infante no puede llenar. El de abajo es que tendrán uno menos. Pero tratando de dividir nuestros datos en dos cubos iguales en base a la partición que hemos definido aquí, y también en base al orden que también hemos definido dentro de nuestra ventana aquí.
45. 43Entender 43UnderstandingQueryPerformanceHB HB: Ahora si realmente te estás metiendo en SQL, tal vez sean algunos puntos. También quieres entender más sobre cómo se planifican o estructuran tus consultas o cuál es el enfoque que se toma para ejecutar y tal vez alguna otra optimización de pasos que puedes hacer. Entonces, para hacer esto, vamos a ejecutar una pequeña consulta de muestra en la tabla de pistas. Y solo ejecutemos una agregación para contar el número de pistas en cada álbum. Entonces vamos a ejecutar el selecto y vamos a seleccionar el ID del álbum. Y entonces lo que también queremos hacer es que queramos contar uno como camiones madereros. Y sólo tengamos este capital sólo para que sea más fácil leer desde la tabla de temas. Y entonces todavía necesitamos agrupar por el ID del álbum. Entonces de nuevo, estamos seleccionando de la mesa de camiones y estamos agrupando por el ID del álbum y solo estamos contando el número de camiones que tiene cada álbum. Entonces si seguimos adelante y ejecutamos esto, estos son los resultados que vamos a obtener. Este es el ID del álbum y este es el número de pistas que tiene. Pero ahora si queremos entender su desempeño, va a ser un poco difícil. Por lo que SQL en realidad tiene una declaración disponible para nosotros llamada Explicar. Y si ejecutamos esto, podemos echarle un vistazo. Esto, en lugar de darnos la salida tal como es, en cambio nos va a dar el plan de la consulta. Ahora no voy a entrar realmente en ningún detalle, pero el plan de consultas, porque el plan de consultas en sí lo es, puede llegar a ser bastante complejo. Y si realmente quieres trabajar en estas optimizaciones, entonces probablemente vas a tener que hacer alguna investigación extra específicamente para entender cómo funciona la diferente agregación, pero también sobre cómo tu base de datos que estás usando es configurada porque las diferentes bases de datos realmente se realizan. Las agregaciones también son solo consultas en general de manera diferente. Porque cuando estamos escribiendo consultas, sólo
estamos diciendo a la base de datos lo que queremos que se haga. Y la propia base de datos realmente realiza y encuentra la forma más óptima de obtener estos valores. Y así esto puede diferir de
base de datos a base de sólo cómo
funciona la base de datos y cómo respira y derechos y
cómo planea y cómo es cómo se indexan los valores y todo esto. Entonces de nuevo, esto es como que va a estar
profundizando en cómo la propia base de datos como puesta a punto. Por eso no vamos a sumergirnos en ello. Pero sin embargo, es importante saber que esta opción está disponible para ti. Y así puedes usar la declaración de explicación para obtener un entendimiento sobre el plan, que el plan de consulta, cómo planea la base de datos
ejecutar la consulta para obtener los resultados que estás buscando. Y entonces también puedes entender, ya sabes, cuántas filas se están procesando o cuántas columnas se están utilizando y en cada componente. O también puedes hacer algo como Explicar, Analizar, que también te dice el tiempo de cómputación, el tiempo de ejecución en lugar de cuánto tiempo tardó realmente la ejecución. Para que puedas profundizar en comprensión de cada uno de estos componentes para que, ya sabes, tal vez puedas encontrar donde la consulta tarda más tiempo y trabajar en optimizar eso. O tal vez entiendas que el, o tal vez encuentres que el enfoque que estás tomando es óptimo en una base de datos, pero en realidad es subóptimo miss uno por la forma en que se configuró. Y así podrás adentrarte realmente en tus consultas y realizar algunas optimizaciones grandes entendiendo la estructura y
el enfoque que tu base de datos tiene tipo de definido como has Howard quiere
acercarse a ejecutar este consulta para conseguirte los resultados que has pedido.