Generando rangos

Me costo un poco de trabajo ya que le aposte al sql de microsoft que es el que comúnmente uso y en que no existe como tal la función pero se puede simular el ejercicio y ya que lo pones en practica es lo mejor.

<----ejercicio 1 vlores con decimales

drop table #Generar_Rangos

create table #Generar_Rangos
(
[Numero] FLOAT not null
)

declare @valorInicial FLOAT = 1.1
declare @valorFinal FLOAT = 4
declare @delta FLOAT = 1.3

;with genera as (
        select @valorInicial as VI
        union all
        select VI+ @delta from genera where VI+ @delta <= @valorFinal
)
insert into #Generar_Rangos (Numero)
select * from genera



select * from #Generar_Rangos




----ejercicio 2 por fechas

drop table #Generar_Rangos

create table #Generar_Rangos
(
[Fecha] date not null
)

declare @valorInicial date = convert (date,getdate ())
declare @valorFinal date = convert (date,getdate ()+10)
declare @delta FLOAT = 2

;with genera as (
        select @valorInicial as VI
        union all
        select  DATEADD(day,@delta,VI) from genera where DATEADD(day,@delta,VI) <= @valorFinal
)
insert into #Generar_Rangos (Fecha)
select * from genera



select * from #Generar_Rangos>

Qué chévere esto de las series. Estoy pensando usarla en el cronograma de una auditoría. Una vez que se registra una auditoría, que muestre el cronograma con las fechas estipuladas para cada revisión.

Esta clases es muy especifica de funciones de postgress , yo creo que sobran o si no que hagan un curso especifico de ello.

Para el reto quise hacer un arbolito de navidad

MI solución al reto:

-- Reto: generar un triángulo a partir de un rango usando generate_series y l o r pad

-- Solucion:

SELECT lpad('\', id, '/') 
FROM generate_series(0,50) as id```

Reto #13

-- Create a triangle with series
SELECT	lpad('(ツ)', s.a, '(ツ)')
FROM platzi.alumnos AS a
	INNER JOIN generate_series(3,30,3) AS s(a)
	ON s.a = a.id
ORDER BY s.a;

El tercer parámetro de generate_series tiene el formato :
{optional}step/interval]

1. El cual indica que no siempre es necesario, como los primeros ejemplos.
2. El parámetro “step” numérico o timestamp
3. El tercer parámetro es el intervalo y en caso de ser timestamp puede pasarse cualquiera de estos :

En MySQL:

La diferencia entre lpad y rpad. Una agrega caracteres desde la izquierda y la otra desde la derecha

Generando Rangos

• Se hace con la función generate_series()
• Genera una tabla con una única columna dinámica
• Recibe tres parámetros
• El primero es el número de inicio de la serie
• El segundo es el final de la serie
• El tercero es el delta o paso, que puede ser negativo si hay overlap
• Overlap es cuando el numero de inicio > numero de final
• Se pueden utilizar fechas
• El delta se puede escribir literal para el caso de timestamps

SELECT *
FROM generate_series('2020-12-06 11:50:00'::timestamp, '2020-10-10 05:30:55', '-7 hours, 23 minutes, 3 seconds'
)

SELECT lpad('*',  generate_series(1,10), '*');

SELECT lpad('*', id, '*')
FROM generate_series(1,10) AS id;

SELECT lpad('*', s.a, '*')
FROM (
	SELECT *
	FROM generate_series(1,10)
	) AS s(a);
	
SELECT lpad(s.a::varchar, s.a,'*'), rpad(s.a::varchar, s.a,'*') 
FROM generate_series(1,10) AS s(a);

Para SQL Server:

-- GENERAR VALORES ENTRE [0; 14] SALTANDO 7
SELECT TOP 3 -- [0,7,14]
	-7 + 7*ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS 'Range'
FROM syscolumns A, syscolumns B


-- METODO 1
-- SUMAR 7 DIAS A LA FECHA ACTUAL Y REPETIR
SELECT CAST(CAST(GETDATE() AS FLOAT) + s.suma_dia AS datetime) AS Fecha
FROM
(
	SELECT TOP 3
		-7 + 7*ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS suma_dia
	FROM syscolumns A, syscolumns B
) AS s



-- METODO 2
-- SUMAR 10 HORAS A UNA FECHA Y REPETIR

-- VERSION 1
SELECT TOP 3 -- [0,7,14]
	CAST(
		CAST(CAST('2020-01-09 00:00:00' AS datetime) AS FLOAT) 
		+ 0.416666667*ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS DATETIME
		) AS 'Range'
FROM syscolumns A, syscolumns B


-- VERSION 2
SELECT TOP 3 
	DATEADD(
			HOUR, 
			10*ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name),
			CAST('2020-01-09 00:00:00' AS datetime)
		   ) AS 'Range'
FROM syscolumns A, syscolumns B


-- METODO 3
-- CREAR UNA TABLA CON INDICES Y MOSTRAR REGISTROS QUE TENGAN ESTOS INDICES
SELECT 
	a.id,
	a.nombre,
	a.apellido,
	a.carrera_id,
	s.id
FROM
	platzi.alumnos AS a
	INNER JOIN 
	(
		SELECT TOP 10 -- [1,10]
		0 + ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS id
		FROM syscolumns A, syscolumns B
	) AS s ON a.carrera_id = s.id
ORDER BY a.carrera_id


/*
CADENA DE ASTERISTOS EN FORMA DE ARBOL
*/
SELECT REPLICATE('*',row_id/2) AS asteriscos
FROM
(	
	SELECT TOP 50
		102 - 2*ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY A.name) AS row_id
	FROM syscolumns A, syscolumns B
) AS alumnos_with_row_id

Les dejo mi solución al reto.
Es poco pero es trabajo honesto.

SELECT lpad('>',s.a,'*')
FROM generate_series(1,10) AS s(a);

SELECT lpad('\', id, '/') 
FROM generate_series(0,50) as id
WHERE id = 2

SELECT lpad('*', s.a, '*')
FROM generate_series(1, 10) AS s(a)

Triangulando con rangos generados.

SELECT lpad('*', s.a, '*')
FROM generate_series(1,15) AS s(a);

SELECT rpad('<', id, '3') 
FROM generate_series(0,20) as id;

Segun entendí yo, se puede hacer una tabla con secuencias, por lo tanto le pido al comando LPAD que tome de ahi los datos.
El resultado es el siguiente codigo:

SELECT lpad ('*', s.a , '*')
FROM generate_series(1,10) AS s(a);

Esta fue mi solución al reto:

SELECT lpad ('SQL',generate_series(1,10,2), '*')

SELECT lpad ('SQL',serie_genial, '*')
FROM generate_series(1,10,2) AS serie_genial;

select lpad('*', generate_series(1 , 20, 2), '*');

Como solución al reto

SELECT lpad('*',raw,'*')
FROM generate_series(1,30) AS raw;

SELECT lpad('-',s.a,'--')
FROM generate_series(0,10) as s(a);

return:

–

…

El reto:

SELECT lpad('*', s.a, '*')
FROM platzi.alumnos
	INNER JOIN generate_series(1,10) AS s(a)
	ON s.a = id
ORDER BY id;

Desafío:

-- Reto: Generar un triangulo a partir rangos generados por ti

SELECT lpad('*',s.a,'*')
FROM generate_series(1,15) AS s(a);

Ejercicio del final de la clase

select lpad('*', s.a, '*')
from generate_series(1, 10) as s(a);

SELECT lpad('*', generate_series(0,15), '*');

Mi solucion al reto

SELECT lpad('+', generate_series(1,10),'+')

Mi solución al reto:

SELECT lpad('*', s.a, '*')
FROM generate_series(1,10) AS s(a);

SELECT lpad ('triangulo', s , '*')
FROM generate_series(1,20) AS s

RETO

-- Triángulo generado mediante rangos autogenerados --
SELECT rpad('HELLO',generate_series(18,0,-2),'*');

SELECT RPAD('a', s.a, '*')
FROM platzi.alumnos AS a INNER JOIN generate_series(1,1000,1) AS s(a) ON a.id = s.a
;

Mi solución:

SELECT lpad('*', new, '*')
FROM generate_series(1,9) AS new;

Solución del reto:

SELECT lpad('a', generate_series(1, 10), '-')

select lpad('sql',id,'*'),
       rpad('sql',id,'*')
from platzi.alumnos
where id < 10;

--Opción Uno
SELECT lpad('*', generate_series(1,5),'*');
--Opción Dos
SELECT lpad('*', s.a, '*')
FROM generate_series(1,5) AS s(a);

My query

SELECT rpad('',s.a,'*')
FROM generate_Series(40,1,-1) AS s(a)

RETO

SELECT LPAD('*', GENERATE_SERIES(1,MAX(carrera_id)),'*')
FROM platzi.alumnos 

Reto:

SELECT lpad('*', generate_series(0,10), '*')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos
) AS alumnos_with_row_id
WHERE row_id <=5; 

solución:

<
SELECT lpad('*',s.a,'*')
FROM generate_series(1,10) AS s(a);
> 

Para MySQL, no es muy práctico pero se puede hacer

SELECT  lpad('>',@curRow := @curRow + 1,'-')
FROM    alumnos 
JOIN    (SELECT @curRow := 0) r
WHERE   @curRow<10;```

Reto

SELECT lpad ('*', s.a ,'*')
FROM generate_series(0,10) AS s(a)

select rpad('*', generate_series(0,10), '*');

Mi solución al reto:

SELECT rpad('*',generate_series(1,15,1),'*');

Se que es innecesario, pero hice también un triangulo invertido:

SELECT rpad('***************',generate_series(15,1,-1),'');

un triangulo con numeros. usando series

Select rpad(s.a::char(12),s.a,s.a::char(12)) from generate_series(1,11) as s(a);

SELECT LPAD('*',serie.a,'*') AS triangulo
FROM(
	SELECT *
	FROM   generate_series(1,10) AS s(a)
)AS serie;

SELECT lpad('x', d, '*')
FROM generate_series(1,5) AS d;

Solución al problema:

SELECT lpad(’’, generate_series(20,1,-2), '’)

Reto hacer el triangulo de padding con un rango generado

SELECT LPAD('h', a, '*')
FROM generate_series(0, 15) AS s(a);

Les comparto mi respuesta 😃

SELECT lpad('*',generate_series(1,10,1),'*')

Sol:

SELECT lpad('*',(generate_series(1,10)),'*')

Poniendo en práctica lo aprendido:

SELECT lpad('ALEX',series.a,'*')
FROM generate_series(1,7) as series(a)

–Reto triangulo con un rango generado

--Reto triangulo con un rango generado
SELECT lpad ('^^',s.a,'\'),rpad ('^^',s.a,'/')
FROM generate_series(1,10) AS s(a)

mi respuesta

select lpad('*',generate_series(1,20),'*');

SELECT LPAD('*', s.a, '*')
FROM GENERATE_SERIES(1, 10) AS s(a)

Reto de generar el triangulo con los datos del curso:

SELECT lpad('*', CAST(row_id AS int),'IZQUIERDA')
FROM (
	SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
	FROM platzi.alumnos) AS alumnos_with_row_id
	JOIN generate_series(5,0,-1) AS s(a) ON s.a = row_id
ORDER BY carrera_id;

Noten que la serie la genero de 5 a 0 para que de el mismo orden que el triangulo convencional.

Mi respuesta al reto:

SELECT lpad('sql', generate_series(1,15), '*');
----------------------------------------------
SELECT lpad('*', id,'*')
FROM platzi.alumnos AS a
    JOIN generate_series(1,10) AS s(a) ON s.a = a.id
WHERE id<10
----------------------------------------------
SELECT lpad('*',CAST(row_id AS int), '*')
FROM (
    SELECT ROW_NUMBER() OVER(ORDER BY carrera_id) AS row_id, *
    FROM platzi.alumnos
) AS alumnos_con_row_id
    JOIN generate_series(1,5) AS s(a) ON s.a = row_id
WHERE row_id<=5
ORDER BY carrera_id;
----------------------------------------------

Los tres elementos dentro del generate_series son:
Inicio, final, saltos(delta) = 1 como default

SELECT *
FROM generate_series(5,1,-2)

En este caso, se decidio cambiar el 1 por -2

RANGOS CON FECHA

SELECT current_date + s.a AS dates
FROM generate_series(0, 14, 7) AS s(a)

Rangos de fechas, con deltas en horas
Ejemplo 1

SELECT *
FROM generate_series('2020-09-01 00:00:00'::timestamp,
					 '2020-09-04 12:00:00', '10 hours')

Ejemplo 2

SELECT a.id,
		a.nombre,
		a.apellido,
		a.carrera_id,
		s.a
FROM platzi.alumnos AS a
	INNER JOIN generate_series(0,10) AS s(a)
	ON s.a = a.carrera_id
ORDER BY a.carrera_id

Para generar un indice con los numeros ordinarios

SELECT *
FROM generate_series(10, 2,-2) WITH ordinality

PARA TRIANGULAR (GEOMETRICA Y GRAFICAMENTE HABLANDO)

SELECT lpad('*', generate_series, '*')
FROM generate_series(1, 10)

Puede ser otra manera de generar los estudiantes en carreras con id entre 1 y 10.

SELECT a.id,
		a.nombre,
		a.apellido,
		a.carrera_id
FROM platzi.alumnos AS a
WHERE a.carrera_id IN (1,2,3,4,5,6,7,8,9,10)
ORDER BY a.carrera_id;

Respuesta al reto

SELECT  lpad('*', generate_series(10, 1, -1), '*'), rpad('*', generate_series(1, 10), '*');

SELECT lpad('*',s.a,'*')
FROM generate_series(1,10,1) AS s(a);

Mi respuesta:

SELECT lpad('*',(generate_series(1,10)),'*')

SELECT lpad('*',n,'*')
FROM generate_series(1,10) as n;