No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Agregando objetos

22/34
Recursos

Aportes 29

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

otra forma un poco mas resumida seria con el uso de ::

ej:

SELECT
MAX(
(info -> ‘items’ ->> ‘cantidad’) :: integer
)
FROM ordenes

Tambien se puede hacer de esta forma sin expresar el CAST

SELECT MIN((INFO -> 'items' ->> 'cantidad') :: integer) min_,
	MAX((INFO -> 'items' ->> 'cantidad') :: integer) max_,
	SUM((INFO -> 'items' ->> 'cantidad') :: integer) sum_,
	AVG((INFO -> 'items' ->> 'cantidad') :: integer) avg_
FROM ORDENES;

Yo trabajé con contrataciones públicas del gobierno federal en México, fue una tortura hacer las consultas en MongoDB, saber esto antes me hubiera ahorra mucho tiempo.

Es importante recalcar que a pesar de que Postgres nos permite realizar operaciones sobre los datos de cadenas JSON este proceso resulta costoso, y es recomendable trabajar con tipos de datos básicos siempre que sea posible.

SELECT 
	SUM(
		-- Cambiando a tipo de dato entero
		CAST( info -> 'items' ->> 'cantidad' AS INTEGER)
	),
	MAX(
		CAST( info -> 'items' ->> 'cantidad' AS INTEGER)
	),
	AVG(
		CAST( info -> 'items' ->> 'cantidad' AS INTEGER)
	)
FROM ordenes;```

Para el motor de Postgres es complejo y computacionalmente costoso, hacer cálculos con objetos tipo JSON

json o jsonb

la diferencia entre estos dos es la forma en la que se almacena los datos json lo almacena literalmente en cambio jsonb lo almacena de una forma mas eficiente además de tener muchas mas funcionalidades que el json, es por esto que en la mayoria de los casos es mejor elegir jsonb pero en casos específicos como mantener el json intacto o realizar muchas inserciones el json sera mejor que el jsonb

para mas información

También se puede hacer de esta manera

SELECT
MIN((info -> ‘items’ ->> ‘cantidad’) :: INTEGER),
MAX((info -> ‘items’ ->> ‘cantidad’) :: INTEGER),
SUM((info -> ‘items’ ->> ‘cantidad’) :: INTEGER),
AVG((info -> ‘items’ ->> ‘cantidad’) :: INTEGER)
FROM ordenes;

Yo habría llamado a esta clase: "Funciones de Agregación en Objetos".

CAST: Transforma un tipo de dato en otro

Cuando traten de hacer operaciones con datos numéricos flotantes, simplemente tienen que especificarlo:

SELECT AVG(
      CAST(
         info -> 'items' ->> 'precio' AS FLOAT
      )
   )
FROM ordenes;

`Utilizando :: ↓` ```js SELECT MAX((info -> 'items' ->> 'cantidad')::INTEGER), MIN((info -> 'items' ->> 'cantidad')::INTEGER), SUM((info -> 'items' ->> 'cantidad')::INTEGER), AVG((info -> 'items' ->> 'cantidad')::INTEGER) FROM orders; ``` ![](https://static.platzi.com/media/user_upload/image-013e82a4-cf2d-4f40-8b9b-1042dec7ec52.jpg)

Nota
Aunque es posible realizar operaciones en objetos JSON, es preferible realizar agregaciones sobre datos primitivos siempre que sea posible, ya que esto suele ser más eficiente en términos de rendimiento.

Va demasiado rápido 😕

¡Claro! En el contexto de PostgreSQL, **agregar objetos** se refiere a trabajar con tipos de datos complejos, como JSON, JSONB, arreglos, o tipos definidos por el usuario para estructurar mejor los datos. Aquí hay un desglose sobre cómo trabajar con **objetos** en PostgreSQL: ### 1. **Creación de Objetos con JSON/JSONB** PostgreSQL soporta nativamente tipos JSON y JSONB para trabajar con datos en formato JSON. Puedes agregar datos estructurados como objetos dentro de tablas. #### Ejemplo: Creación de una tabla con JSONB CREATE TABLE productos ( id SERIAL PRIMARY KEY, nombre VARCHAR(100), detalles JSONB ); #### Inserción de un objeto JSON INSERT INTO productos (nombre, detalles) VALUES ('Laptop', '{"marca": "Dell", "especificaciones": {"ram": "16GB", "procesador": "i7"}}'); ### 2. **Acceso y Consulta de Objetos JSON** PostgreSQL permite trabajar con funciones específicas para manipular JSON. #### Ejemplo: Acceso a campos dentro de JSON SELECT detalles->'marca' AS marca FROM productos; #### Ejemplo: Acceso a valores anidados SELECT detalles#>>'{especificaciones, ram}' AS memoria\_ram FROM productos; ### 3. **Actualización de Objetos JSON** Puedes modificar partes del JSON utilizando funciones como `jsonb_set`. #### Ejemplo: Actualizar un valor UPDATE productos SET detalles = jsonb\_set(detalles, '{especificaciones, ram}', '"32GB"') WHERE nombre = 'Laptop'; ### 4. **Creación de Tipos de Datos Personalizados** Puedes definir tus propios tipos de datos en PostgreSQL para representar objetos más complejos. #### Ejemplo: Tipo personalizado para direcciones CREATE TYPE direccion AS ( calle VARCHAR, ciudad VARCHAR, codigo\_postal VARCHAR ); #### Uso del tipo personalizado en una tabla CREATE TABLE usuarios ( id SERIAL PRIMARY KEY, nombre VARCHAR(50), direccion direccion ); INSERT INTO usuarios (nombre, direccion) VALUES ('Juan', ROW('Calle 123', 'Bogotá', '110111')::direccion); ### 5. **Agregando Arreglos como Objetos** Puedes utilizar arreglos para almacenar listas como objetos. #### Ejemplo: Tabla con arreglos CREATE TABLE pedidos ( id SERIAL PRIMARY KEY, cliente VARCHAR, productos TEXT\[] ); INSERT INTO pedidos (cliente, productos) VALUES ('Ana', ARRAY\['Producto1', 'Producto2', 'Producto3']); #### Consulta de arreglos SELECT productos\[1] AS primer\_producto FROM pedidos;
Dejo mi Query dejando con dos decimales el promedio: SELECT MIN( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), MAX( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), SUM( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), ROUND( AVG( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ),2 ) FROM ordenes;
SELECT MIN( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), MAX( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), SUM( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ), ROUND( AVG( CAST( info -> 'items' ->> 'cantidad' AS INTEGER ) ),2 ) FROM ordenes;

22. Agregando objetos

SELECT 
	MIN(
		CAST (
			  info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	MAX(
		CAST (
			  info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	AVG(
		CAST (
			  info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	SUM(
		CAST (
			  info -> 'items' ->> 'cantidad' AS INTEGER
		)
	)
FROM ordenes;

Excelente conocer este aspecto, le da mas valor y conocimiento a la hora de presentar información sin complicarse la vida

Esta es como una forma más resumida para trabajar. Ya no quiero bajar tablas sino una columna en jason y desde ahi trabajar con la información e ir dando formato al campo a medida que lo necesite

Interesante este manejo con JSON

Entendido, hay que tener en cuenta el rendimiento

SELECT 
	MIN(
		CAST(
			info -> 'items' ->> 'cantidad' AS INTEGER
		)
	)
FROM ordenes;

SELECT 
	MIN(
		CAST(
			info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	MAX(
		CAST(
			info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	SUM(
		CAST(
			info -> 'items' ->> 'cantidad' AS INTEGER
		)
	),
	AVG(
		CAST(
			info -> 'items' ->> 'cantidad' AS INTEGER
		)
	)
FROM ordenes;

excelente

interesante

El lenguaje plsql es demasiado poderoso.

Excelente las posibilidades que esto representa.

Muy interesante saber las dos formas, he usado mySQL y CAST se aplica de la misma forma que Postgres ```js SELECT MIN( CAST(info -> 'items' ->> 'cantidad' as integer) ) as minCantidad, MAX( CAST(info -> 'items' ->> 'cantidad' as integer) ) as maxCantidad, AVG( (info -> 'items' ->> 'cantidad') :: float ) as avgCantidad, SUM( (info -> 'items' ->> 'cantidad') :: integer ) as sumCantidad FROM ordenes; ```

Muy interesante trabajarlo casi nativo y muy útil ya que trabajamos los datos sin utilizar una capa de negocios.