Objeto grande Postgres

Los objetos grandes (LOB) son aquellas colecciones de tipo de datos que se crean para contener una gran cantidad de datos hasta un tamaño máximo que varía de 8 terabytes a 128 terabytes. Depende principalmente de la configuración de una base de datos.

Por qué se usan objetos grandes en PostgreSQL

Explicaremos diferentes tipos de datos que son adecuados para objetos grandes y su propósito de creación.

• Datos estructurados: Este es un tipo simple de datos estructurados y se puede crear en una tabla simple.
• Datos estructurados complejos: Estas son estructuras complejas y se crean para gestionar las características de los objetos relacionales de la base de datos Oracle, como colecciones y referencias.
• Datos no estructurados: Estos tipos de datos no son interpretados por la base de datos y este tipo de datos no se dividen en estructuras lógicas más pequeñas.

Sintaxis

# Crear tabla table_name (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

Se crea una tabla para un objeto grande con el tipo de datos de una columna específica que tiene un bytea o blob para almacenar los valores para un objeto grande como imágenes o videos.

Implementación

Crearemos una tabla con el tipo de datos de blob en una columna, mientras que otras columnas tienen tipos de datos enteros y varchar. Pero en la ejecución de una consulta, esto causa un error al mostrar que el tipo 'blob' no existe.

>> Crear tabla TBL_BLOB (TBL_BLOB BLOB, ID Integer, Name Varchar (10), Dirección Varchar (10));

Crearemos los mismos atributos de tabla nuevamente al tener la primera columna con el tipo de datos de 'bytea'. Este es también un tipo de variable de datos tipo blob. Al usar esto, podemos restaurar los datos del tipo binario en PostgreSQL.

>> Crear tabla TBL_BLOB (TBL_BLOB BYTEA, ID Integer, Name Varchar (10), Dirección Varchar (10));

Esto se hizo para mostrar la diferencia en el uso de blob y bytea. La mayoría de las veces, Blob no es compatible con algunas versiones de PostgreSQL; Por eso usamos bytea en el comando.

Se volverá a crear una nueva tabla de muestra para probar el uso del objeto grande. Se crea una tabla llamada TBL_BLOB1.

>> Crear tabla TBL_BLOB1 (TBL_BLOB BYTEA, ID Integer, Name Varchar (10), Dirección Varchar (10), Clase

varchar (10)); [/cc]

Después de crear la tabla, ahora veremos la descripción de la tabla para notar el tipo de almacenamiento y los tipos de columnas.

>> \ d+ tbl_blol1;

Puede ver en la imagen de arriba que se muestran los nombres de la columna y el tipo de datos. El método utilizado para acceder a esta descripción es el tipo de montón. Para explicar el uso de objetos grandes en más de una columna, volveremos a crear una tabla. Esta tabla contendrá más de una columna que tiene el tipo de datos de objeto grande.

>> Crear tabla TBL_BLOB2 (TBL_BLOB bytea, tbl1_blob bytea, tbl2_blob bytea, id entero, nombre varchar (10), dirección varchar (10), class varchar (10));

Después de la creación, vuelva a usar el comando escrito a continuación para ver la descripción de la tabla.

>> \ d+ tbl_blob2;

Hasta ahora, hemos visto el uso de Blob mientras creamos la mesa. Pero para agregar una nueva columna que tiene un tipo de datos de bytea y blob, necesitamos un comando de actualización. En la tabla TBL_BLOB1, hemos agregado una columna llamada TBL1_BLOB que tiene el tipo de datos de bytea.

>> Tabla alter TBL_BLOB1 Agregar columna TBL1_BLOB bytea;

Creación de objetos grandes en PostgreSQL

Existe una función para crear un objeto grande.

# Oid lo_creat (pgconn *con, intdo int);

En esta función, 'Modo' es una masilla de bits que se usa para describir diferentes atributos del objeto que se crea recientemente. Mientras que las constantes utilizadas en la función están presentes en la biblioteca del archivo de encabezado libpq-fs. Aquí aplicamos un ejemplo de muestra para la creación de objetos grandes, en el que el valor es devuelto y aceptado por una variable.

# inv_oid = lo_creat (inv_read | inv_write);

La lectura y la escritura son los tipos de acceso utilizados en la función. Un argumento "-1" se usa como un parámetro de la función lo_creat () para crear un objeto grande en el ejemplo dado. Esto se usa para crear un nuevo gran, vacío, que muestra el índice como nulo.

>> seleccione LO -_Creat (-1);

PostgreSQL asigna un valor aleatorio. Para proporcionar un valor específico para crear un objeto grande, proporcionamos un valor de nuestra propia elección en el parámetro.

>> seleccionar lo_create (9945621);

Importar objeto grande

Si desea importar un archivo presente en cualquier directorio de su sistema operativo como objeto grande, entonces esto se puede usar como una llamada de función.

# Oid lo_import (pgconn *conn, const char *name_of_file);

Name_of_file es el archivo específico que desea importar del sistema como objeto grande. El valor OID asignado a un nuevo objeto grande es el valor devuelto.

Exportar un objeto grande

Contrariamente a la importación, también se pueden exportar objetos grandes al sistema operativo. Se realiza una llamada de función para exportar el objeto grande.

# Int lo_export (PGCON *Conn, oid lobjid, constante char *name_of_file);

OID se muestra por Lobjid. Se especifica OID para el objeto que debe exportarse desde PostgreSQL al sistema operativo. El argumento del nombre de archivo es que especifica el nombre del sistema operativo. Se crea una ID de objeto grande para admitir la exportación del archivo desde PostgreSQL al sistema operativo.

Abra un objeto grande que ya existe en PostgreSQL

Si desea abrir un detalle de objeto grande que ya está presente y creado antes en PostgreSQL, entonces se usa la siguiente función.

# Int lo_open (pgcon *con, oid lojid, ints Mode);

El objeto grande se abre para cualquier propósito como leer o escribir o para ambos, se puede realizar cualquier actualización. 'Lo_open' Una variable de tipo entero, devuelve el objeto grande para su uso posterior en Lo_Write, Lo_read o Lo_Close.

Escribir/leer datos a/desde el objeto grande

Escribir datos a objeto grande

# Int lo_write (PGCON *Conn, int fx, const char *buffr, size_t lenn);

El objeto grande FX se usa para escribir en la longitud de Lenn de Buffer Buffr. Los bytes que se escriben se devuelven. Si el valor de retorno es negativo, entonces significa que ha ocurrido un error.

Leer datos

# Int lo_read (pgconn *con, int fx, char *buffr, size_t lenn);

Esta función lee los bytes de longitud de Lenn del objeto grande en un búfer buffr. El valor se devuelve como lo hace el proceso de escritura.

Extracción de objetos grandes

>> int lo_unlink (pgconn *con, oid lobjid);

Hemos utilizado el ejemplo citado a continuación usando un comando seleccionar con un número OID. El 'lo_unlink' se usa para eliminar el OID.

>> seleccione lo_unlink (9945621);

Implementar comandos de objetos grandes

Usaremos algunas de las características mencionadas anteriormente de un objeto grande en el shell PSQL. El primer comando de creación se usa para crear una tabla del objeto grande como lo hicimos arriba.

>> Crear tabla Pic (ID entero, texto de nombre, pic oid);

Aquí la tabla se crea para almacenar la información de una imagen que tiene el tipo de datos de ID de objeto grande.

Insertar valores en la tabla

>> Insertar en PIC (ID, Nombre, Pic) Valores (1, 'mi imagen', lo_import ('/etc1/mottd'));

Aquí se selecciona una imagen del sistema operativo.

Conclusión

El artículo 'Postgres Grand Object' contiene la descripción de la especialidad de usar el objeto grande, sus tipos y algunas funciones importantes utilizadas para crear, importar y exportar grandes objetos Postgresql. Algunas de las características se implementan en el shell PostgreSQL para elaborar la creación y el funcionamiento de los objetos grandes para almacenar datos.