Working with Large Objects (LOBs) in PostgreSQL
In the world of databases, particularly in PostgreSQL, you'll often find yourself working with large objects. Large Objects (LOBs) in PostgreSQL refer to data types which allow storage of binary data (BLOB) and character data (CLOB). The size of these objects can exceed the maximum size of a regular row and they are usually stored separately with a reference maintained in the table. PostgreSQL also supports the BLOB and CLOB data types for compatibility with SQL92.
Working with large objects can be a bit daunting for beginners, especially when it comes to handling and managing their storage and retrieval efficiently. However, with the right understanding and practices, you can comfortably and efficiently handle LOBs in PostgreSQL. This blog post aims to make you familiar with these practices and equip you with the tools you need to work with large objects in PostgreSQL.
Understanding Large Objects in PostgreSQL
Before diving into the operations involving large objects, it's essential to understand what they are and why they are needed.
Large objects or LOBs are a way to store binary and text data in PostgreSQL. Unlike normal data types like
boolean, which are limited in size, LOBs allow storage of objects that can be several gigabytes in size. Two main types of LOBs are
BLOB (Binary Large Object) and
CLOB (Character Large Object). They are typically used for multimedia data, such as images, audio, or large pieces of text.
CREATE TABLE my_table ( id serial PRIMARY KEY, name varchar(100), image bytea, document text );
In the above example,
bytea is used for binary data like an image, and
text is used for large text data.
Working with LOBs
To work with LOBs in PostgreSQL, you'll need to use specific functions provided by PostgreSQL. The basic operations include creating a large object, opening it, reading from it, writing to it, seeking within it, and finally, closing it.
Let's start by creating a large object.
Creating a Large Object
lo_create function is used to create a new large object and returns the OID of the newly created object.
Opening a Large Object
You can open a large object using the
lo_open function. This function takes two parameters: the OID of the large object, and a mode parameter that can be either
SELECT lo_open(12345, INV_WRITE);
Writing to a Large Object
Once the large object is opened, you can write to it using the
SELECT lowrite(12345, 'Hello, World!');
This will write the string 'Hello, World!' to the large object with OID 12345.
Reading from a Large Object
To read from a large object, you can use the
SELECT loread(12345, 13);
This will read 13 bytes from the large object with OID 12345.
Seeking Within a Large Object
Sometimes, you might want to jump to a certain position within a large object. This can be done using the
SELECT lo_lseek(12345, 7, SEEK_SET);
This will move the pointer to the 7th byte in the large object.
Closing a Large Object
After all operations are complete, you should close the large object using the
Thiswill close the large object with OID 12345.
Deleting a Large Object
To delete a large object from the database, you can use the
lo_unlink function. This function takes the OID of the large object to be deleted as a parameter.
This will delete the large object with OID 12345.
Importing and Exporting Large Objects
There are two utility functions that you can use to export and import large objects from and to the file system.
Importing a Large Object
lo_import function can be used to import a file from the file system as a large object in the PostgreSQL database. This function takes the path to the file as a parameter and returns the OID of the newly created large object.
Exporting a Large Object
lo_export function can be used to export a large object from the PostgreSQL database to the file system. This function takes two parameters: the OID of the large object to export, and the path to the file to be created.
SELECT lo_export(12345, '/path/to/myfile');
1. What are the common use-cases for LOBs in PostgreSQL?
LOBS are commonly used when there is a need to store large amounts of data such as images, audio files, video files, or large amounts of text data. They can also be used for storing binary data.
2. What is the maximum size of a large object in PostgreSQL?
The maximum size of a large object in PostgreSQL is 4 terabytes.
3. How to check the size of a Large Object in PostgreSQL?
You can use the
pg_total_relation_size function to check the size of a large object. It will return the total disk space used by the table, including all its indexes, toast tables, and free space map.
4. How to optimize the storage and retrieval of large objects in PostgreSQL?
Storage and retrieval of large objects can be optimized by using appropriate data types, making use of the
toast storage system, and setting up the
large object storage parameter appropriately. It's also crucial to maintain the database regularly and perform vacuum operations to remove dead tuples.
Sharing is caring
Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.
No comments so far
Leave a question/feedback and someone will get back to you