Triangulando

Illuminati detected
No me sorprende que la clase sea la 21 =(3x(3+3+1)).

Lpad: rellena por la izquierda.
P.e. lpad(‘437’,5,‘0’)
tendría como resultado 00437.

RPad: rellena por la derecha.
P.e. rpad(‘437’,5,‘0’)
tendría como resultado 43700.

Se podría aplicar para presentar un “diagrama de barras comparativas” de una variable, por ejemplo la colegiatura, en el caso que en la capa superior no sea posible.

SELECT CONCAT(nombre, ' ', apellido) ,colegiatura, LPAD('|', CAST(colegiatura AS int)/100, '|') AS coleg_bar
FROM platzi.alumnos;

SELECT lpad(‘ji’,100,‘ji’);

🙀 OMG amigos, no sabía que también se podían usar emojis como relleno. Miren!

Les quiero compartir una aplicación de lpad, cree un columna PROMEDIO en la tabla alumnos, le puse valores aleatorios del 1 al 10, y con lpad cree una columna adicional llamada PUNTAJE la cual muestra de manera grafica, con estrellas que tan bien va el alumno, si su promedio es de 10 o 9 tiene 5 estrellas , si tiene 8 o 7, 4 estrellas y así sucesivamente

Les comparto lo que me aparece en PDAdmin

Hola, creo que esta clase puede ser muy útil para tokenizar información sensible de usuarios, comparto la query 😃

/* TOKENIZANDO */
SELECT rpad(SUBSTR(nombre, 1, 2),LENGTH(nombre),'*'), nombre,
       rpad(SUBSTR(apellido, 1, 2),LENGTH(apellido),'*'), apellido,
	   rpad(SUBSTR(email, 1, 2),LENGTH(email),'*'), email
FROM platzi.alumnos

Si están utilizando SQL Server:

Ya me quedo mucho mas claro como funcionan .

<
/* right Join todo de la tabla de alumnos */
SELECT 
a.[nombre]
,a.[apellido]
,a.[carrera_id]
,b.id
,b.carrera
FROM [HAHM].[dbo].[platzialumnos] a
right join platzicarreras b on a.carrera_id = b.id
where b.carrera is not null 
order by carrera desc


/* Left Join todo de la tabla de alumnos */
SELECT 
a.[nombre]
,a.[apellido]
,a.[carrera_id]
,b.id
,b.carrera
FROM [HAHM].[dbo].[platzialumnos] a
left join platzicarreras b on a.carrera_id = b.id
where b.id is not null 
order by carrera desc


/* inner Join todo lo que coincida en ambas tablas */
SELECT 
a.[nombre]
,a.[apellido]
,a.[carrera_id]
,b.id
,b.carrera
FROM [HAHM].[dbo].[platzialumnos] a
inner join platzicarreras b on a.carrera_id = b.id
order by carrera desc



/* Full Join */
SELECT 
a.[nombre]
,a.[apellido]
,a.[carrera_id]
,b.id
,b.carrera
FROM [HAHM].[dbo].[platzialumnos] a
full join platzicarreras b on a.carrera_id = b.id
order by carrera desc





>

He utilizado estas funciones en consultas donde los campos resultados estaban destinados a un archivo de texto formateado donde debía respetar la longitud de cada campo completando a derecha o izquierda con espacios en blanco o con ceros, para campos alfanuméricos y numéricos respectivamente.

Lpad is izquierda
Rpad para la derecha

21. Triangulado

SELECT lpad('sql',15,'+')

SELECT  lpad('*',id,'*')
FROM platzi.alumnos
WHERE id < 10
ORDER BY carrera_id

SELECT lpad('*',CAST(row_id AS int),'*')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos
)AS alumnos_with_row_id
WHERE row_id <= 5
ORDER BY carrera_id

;

-- La función RPAD se utiliza para agregar caracteres a la derecha de una cadena. Si la cadena original es más corta que la longitud especificada, se agregarán caracteres a la derecha hasta alcanzar esa longitud.

SELECT rpad('sql', 15, '*');

SELECT rpad('sql', id, '*')
FROM platzi.alumnos
WHERE id <= 10;

SELECT rpad('*', id, '*')
FROM platzi.alumnos
WHERE id <= 10;

SELECT rpad('*', id, '*')
FROM platzi.alumnos
WHERE id <= 10
ORDER BY carrera_id;

SELECT rpad('*', CAST(row_id AS int), '*')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_id
WHERE row_id <= 10
ORDER BY carrera_id;

SELECT
 	lpad('*|*', CAST(row_id AS int), 'Soy un relleno que va a la izquierda'),
	rpad('*|*', CAST(row_id AS int), 'Soy un relleno que va a la derecha')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_id
WHERE row_id <= 50
ORDER BY carrera_id;

Bueno,
rpad rellena por la derecha en este ejemplo toma el texto hola y lo va rellenando con * a la derecha

SELECT rpad('hola', id, '*')
FROM platzi.alumnos
where id <10```

Yo cuando la solución requiere usar windows functions

No encontré su similar en sql de microsoft, la forma en la que lo resolví es con replicate y extrayendo los datos con un right.

<SELECT  right((REPLICATE('+', 15) + 'sql'),15)  AS 'Line Code'  >

Para SQL Server:

-- GENERAR UNA CADENA DE CIERTO TAMAÑO
DECLARE @TEX VARCHAR(20) = 'SQL'
DECLARE @TAM INT = 6
SELECT RIGHT(REPLICATE('*',3) + @TEX, @TAM) 
SELECT LEFT(@TEX + REPLICATE('*', 3), @TAM)



-- CADENA CON LOS ID Y ASTERISCOS
USE [platzi]
DECLARE @TAM INT = 10
SELECT 
	RIGHT(REPLICATE('*',3) + CAST(id AS CHAR(4)), @TAM) AS derecha,
	LEFT(CAST(id AS VARCHAR(4)) + REPLICATE('*', 3), @TAM) AS izquierda
FROM platzi.alumnos
WHERE id < 101
GO


-- CADENA DE ASTERISTOS DEL TAMAÑO DEL ID
USE [platzi]
DECLARE @TAM INT = 10
SELECT REPLICATE('*',id) AS asteriscos	
FROM platzi.alumnos
WHERE id < 50
GO


-- CADENA DE ASTERISTOS DEL TAMAÑO DEL ID ORDENADO
USE [platzi]
SELECT REPLICATE('*',row_id) AS asteriscos
FROM
(	
	SELECT ROW_NUMBER() OVER(ORDER BY id) AS row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_id
WHERE row_id < 50
GO

Diferencia entre LPAD y RPAD

• LPAD -> rellena a la izquierda de un carácter especial predeterminado y las veces que se requiera
  Ejemplo: SELECT LPAD(NAME,4,’.’ ) AS NAME FROM T1;
  Resultado: Noel, .Sol, …Lu
• RPAD -> rellena a la derecha de un carácter especial predeterminado y las veces que se requiera
  Ejemplo: SELECT RPAD(NAME,5,’.’ ) AS NAME FROM T1; Resultado: Diana, Ted…, Jeff.

Reto:
rpad sirve para hacer relleno a la derecha

es la misma función pero esta nos permite colocar ese número n de caracteres a la derecha mientras el que vimos nos permite colocarlos a la izquierda

Basicamente lpad, rellenará los espacios sin caracteres empezando desde la izquierda. Mientras que rpad lo hace desde la derecha.

La función lpad pone todos los rellenos a la izquierda mientras que el rpad las pone a la derecha muy interesante lo aprendido

INNER JOIN:

SELECT *
FROM platzi.alumnos
INNER JOIN platzi.carreras ON platzi.alumnos.carrera_id = platzi.carreras.id;

• Esta consulta selecciona todas las columnas de ambas tablas donde hay coincidencias en las columnas carrera_id de la tabla alumnos e id de la tabla carreras.

LEFT JOIN:

SELECT *
FROM platzi.alumnos
LEFT JOIN platzi.carreras ON platzi.alumnos.carrera_id = platzi.carreras.id;

• Esta consulta devuelve todas las filas de la tabla alumnos y las coincidencias correspondientes de la tabla carreras. Si no hay coincidencias, las columnas de la tabla carreras tendrán valores nulos.

RIGHT JOIN:

SELECT *
FROM platzi.alumnos
RIGHT JOIN platzi.carreras ON platzi.alumnos.carrera_id = platzi.carreras.id;

• Esta consulta devuelve todas las filas de la tabla carreras y las coincidencias correspondientes de la tabla alumnos. Si no hay coincidencias, las columnas de la tabla alumnos tendrán valores nulos.

FULL OUTER JOIN:

SELECT *
FROM platzi.alumnos
FULL OUTER JOIN platzi.carreras ON platzi.alumnos.carrera_id = platzi.carreras.id;

• Esta consulta devuelve todas las filas cuando hay una coincidencia en cualquiera de las tablas. Si no hay coincidencias, las columnas sin coincidencias tendrán valores nulos.

-- Ejercicio 11 / Mencione diferencia entre función ipad y rpad

SELECT lpad('sql', 15, '+');

SELECT rpad('sql', 15, '+');

SELECT lpad('*', id, '/'), carrera_id
FROM platzi.alumnos
WHERE id < 10

SELECT rpad('*', id, '/'), carrera_id
FROM platzi.alumnos
WHERE id < 10

-- La función rpad coloca la cadena al final mientras que la función lpad la coloca al inicio

Si se usa el rpad en vez de lpad, se obtendría un patron de asteriscos hacia la derecha en vez de hacia la izquierda.

LPAD: Esta función se utiliza para rellenar una cadena de texto con caracteres específicos desde la izquierda hasta alcanzar una longitud deseada.

RPAD: Similar a LPAD, pero en lugar de rellenar desde la izquierda, lo hace desde la derecha.

Con rpad sql va antes que los signos![](

![](

Reto: Jugar con la otra funcion llamada rpad e indicar la diferencias encontradas

Esta funcion hace lo contrario que lpad, rellena en este caso de derecha a izquierda

SELECT rpad('sql', 15, '*');

SELECT rpad('sql', id, '*')
FROM platzi.alumnos 
WHERE id < 10;

SELECT rpad('sql', id, '*')
FROM platzi.alumnos
WHERE id < 10
ORDER BY carrera_id;

SELECT rpad('sql', CAST(row_id AS int), '*')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, * 
	FROM platzi.alumnos
)AS alumnos_with_row_id
WHERE row_id <= 10
ORDER BY carrera_id;

rpad, lo que hace es colocar el espacio en la derecha, mientras que la lpad lo coloca del lado izquierdo.

mi aporte al reto:

--- agregar (N) cantinad de cualquier caracter (en este ejemplo *) la izquierda de una palabra 
SELECT LPAD('sql',15,'*');

--- agregar (N) cantinad de cualquier caracter (en este ejemplo espacios) la izquierda de una palabra 
SELECT LPAD('sql',15,' ');

--- agregar (N) cantinad de cualquier caracter (en este ejemplo *) la derecha de una palabra 
SELECT RPAD('sql',15,'*');

--- agregar (N) cantinad de cualquier caracter (en este ejemplo espacios) la derecha de una palabra 
SELECT RPAD('sql',15,' ');

--- ejercicio de pading con una variable
SELECT LPAD ('*',id,'*')
FROM curso.alumnos
Where id < 10;

--- Ejercicio de pading con 1 variable y un ordenamiento especifico
SELECT LPAD ('*',id,'*'), carrera_id
FROM curso.alumnos
Where id < 10
ORDER BY carrera_id;

--- Ejercicio
SELECT LPAD ('+', CAST(row_id AS int), '+' )
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM curso.alumnos
) AS Alumnos_row_id
WHere row_id <= 7;

rpad coloca el relleno del lado derecho. En el ejemplo de la cadena sql la salida con rpad sería: sql************
Observé que cuando se usa rpad y lpad para obtener el relleno con puntos el resultado es el mismo

En rpad rellena por la derecha. Ejemplo:

SELECT rpad(‘sql’,CAST(row_id AS int),’’)
FROM (
SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id,
FROM platzi.alumnos
)AS alumnos_with_row_id
WHERE row_id <=5
ORDER BY carrera_id;

En el valor 5 -> sql**

La principal diferencia es que ** lpad ** coloca la cadena principal a la izquiera y la subcadena a la derecha mientras que rpad es a la inversa.

RPAD agrega caracteres a la cadena a la derecha

Select rpad('sql', 10,'-')


SELECT RPAD('+',id,('+'))
FROM platzi.alumnos
WHERE id<8 

SELECT rpad (’’,CAST(row_id AS int) ,’’), carrera_id
FROM (
SELECT ROW_NUMBER () OVER () AS row_id, *
FROM platzi.alumnos
)AS alumnos_with_row_id
WHERE row_id <= 5;

**RPAD ** rellena al final.
LPAD rellena al inicio.

jugando con las funcione logre hacer un triangulo por ambos lados

SELECT CONCAT(
		LPAD(RPAD('*',id,'*'),11,'_'),
		LPAD('*',id,'*')
	)
FROM platzi.alumnos
WHERE id<10

De hecho, uno puede hacer lo siguiente y seguiría funcionando

SELECT lpad('', id, '*')
FROM students
LIMIT 10;

Resultado:
*
**

-- con estrellitas
select rpad('✰', id, '✰')
from alumnos
where id <20;

Chevere, lpad agrega lo que colocó en el tercer parámetro al lado izq.
Ejemplo:

SELECT lpad('suku',20,'--');
return: ----------------suku

y rpad al lado der.

SELECT rpad('suku',20,'--');
return: suku----------------

Desafío:

SELECT rpad('sql',15,'+'); --right padding

-- Función que acolchona pero a la derecha en lugar de a la izquieda como lpad

select rpad('sql', 15, '-')

Realiza un relleno completo pero del lado derecho

Con rpad el relleno lo hace hacia la derecha a diferencia de lpad que es hacia la izquierda.

LPAD
Rellena a la izquierda

SELECT lpad('sql', 15, '*') 

Result: *******sql

LPAD
Rellena a la derecha

SELECT rpad('sql', 15, '*') 

Result: sql*******

select rpad(‘3’,5, ‘0’)

select lpad(‘3’,5, ‘0’)

como fuee…

Reto #12

-- Making two triangles
SELECT CONCAT(lpad('*', CAST(row_id AS int), '*'), '¯\_( ͡° ͜ʖ ͡°)_/¯', rpad('*', id, '*'))
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY id DESC) row_id, *
	FROM platzi.alumnos
	WHERE id < 10
) AS alumnos_row_number
WHERE id < 10;

Triangulando

• Existen funciones de padding (lpad, rpad) que permiten “rellenar” un string con un tamaño especificado por parámetro
• Por ejemplo si ordenamos por id del 1 al 15 y damos la longitud del string por id nos queda un triángulo

SELECT lpad('*', id, '*')
FROM platzi.alumnos
LIMIT 15

La diferencia principal es que el espacio se llena esta vez a la derecha, si ponemos sql con 10 espacios el resultado es

sql*******

rpad hace lo mismo que dpad, solo coloca la cadena del lado derecho ejemplo select lpad(‘hola’, 3,’’); daria por resultado hola y rpad(‘hola’, 3,’’); daria hola, esta funcion puede ser util al momento de censurar contraseñas y correos

Les dejo por acá una explicación corta y sencilla de LPAD y RPAD

https://docs.aws.amazon.com/es_es/redshift/latest/dg/r_LPAD.html

LPAD (string1, length, [ string2 ])

RPAD (string1, length, [ string2 ])```

Select rpad('sql',15,'*');

Select rpad('sql',id,'*') 
from platzi.alumnos
Where id < 10;

Select rpad('*',id,'*') 
from platzi.alumnos
Where id < 10;

Select rpad('*',id,'*'), carrera_id
from platzi.alumnos
Where id < 10
order by carrera_id;

No te lo puedo creer

SET @base = 5;

SELECT CONCAT(LPAD("*", @base - id, " "), LPAD("", id -1, "*"))
FROM platzi.alumnos
WHERE id < @base;```

lpad rellena por la izquierda
**rpad **rellena por la derecha

SELECT lpad('sql',id,'*'),
	   rpad('sql',id,'*') 
FROM platzi.alumnos
WHERE id < 10;```

Estas funciones anteponen o anexan caracteres a una cadena, según una longitud especificada.

SELECT rpad('*', CAST(row_id AS int), '*')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_id
WHERE row_id <= 10
ORDER BY carrera_id;

RETO

SELECT LPAD(CONCAT(nombre, apellido), 20, '-'), RPAD(CONCAT(nombre, apellido), 20, '-')
FROM platzi.alumnos;