34.3. Клиентские интерфейсы #
- 34.3.1. Создание большого объекта
- 34.3.2. Импорт большого объекта
- 34.3.3. Экспорт большого объекта
- 34.3.4. Открытие существующего большого объекта
- 34.3.5. Запись данных в большой объект
- 34.3.6. Чтение данных из большого объекта
- 34.3.7. Перемещение в большом объекте
- 34.3.8. Получение текущего положения в большом объекте
- 34.3.9. Усечение большого объекта
- 34.3.10. Закрытие дескриптора большого объекта
- 34.3.11. Удаление большого объекта
- 34.3.2. Импорт большого объекта
В этом разделе описываются средства, которые предоставляет клиентская библиотека Postgres Pro libpq для обращения к большим объектам. Интерфейс работы с большими объектами Postgres Pro создан по подобию интерфейса файловых систем Unix, так что он включает аналоги функций open, read, write, lseek и т. д.
Все операции с большими объектами с применением этих функций должны иметь место в блоке транзакции SQL, так как дескрипторы больших объектов актуальны только во время транзакции. Операции записи, в том числе lo_open в режиме INV_WRITE, не допускаются в читающих транзакциях.
Если при выполнении одной из этих функций происходит ошибка, эта функция возвращает значение, иначе невозможное, обычно 0 или -1. Сообщение, описывающее ошибку, сохраняется в объекте соединения; получить его можно с помощью PQerrorMessage .
Клиентские приложения, которые используют эти функции, должны включать заголовочный файл libpq/libpq-fs.h и компоноваться с библиотекой libpq.
Клиентские приложения не могут использовать эти функции, когда соединение libpq находится в конвейерном режиме.
34.3.1. Создание большого объекта #
Oid lo_create(PGconn *conn, Oid lobjId);
создаёт новый большой объект. В lobjId можно задать назначаемый ему OID; при этом произойдёт ошибка, если этот OID уже присвоен какому-либо большому объекту. Если в lobjId передаётся InvalidOid (ноль), lo_create присваивает большому объекту свободный OID. Возвращаемым значением будет OID, назначенный новому большому объекту, либо InvalidOid (ноль) в случае ошибки.
Пример:
inv_oid = lo_create(conn, desired_oid);
Oid lo_creat(PGconn *conn, int mode);
также создаёт новый большой объект, всегда присваивая ему неиспользуемый OID. Возвращаемое значение — это OID, присвоенный новому большому объекту, или InvalidOid (ноль) в случае ошибки.
В PostgreSQL версии 8.1 и выше режим игнорируется, так что вызов lo_creat полностью равнозначен вызову lo_create с нулевым вторым аргументом. Однако едва ли стоит использовать lo_creat, если вам не нужно работать с серверами версии ниже 8.1. Чтобы работать с таким старым сервером, вы должны использовать lo_creat, а не lo_create, и передать в аргументе режим значение INV_READ, INV_WRITE или INV_READ | INV_WRITE. (Эти символические константы определены в заголовочном файле libpq/libpq-fs.h.)
Пример:
inv_oid = lo_creat(conn, INV_READ|INV_WRITE);
34.3.2. Импорт большого объекта #
Чтобы импортировать в качестве большого объекта файл операционной системы, вызовите
Oid lo_import(PGconn *conn, const char *filename);
В filename задаётся имя файла в операционной системе, который будет импортирован как большой объект. Возвращаемым значением будет OID, назначенный новому большому объекту, либо InvalidOid (ноль) в случае ошибки. Заметьте, что этот файл читает библиотека клиентского интерфейса, а не сервер; таким образом, он должен существовать в файловой системе на стороне клиента и быть доступным для чтения клиентскому приложению.
Oid lo_import_with_oid(PGconn *conn, const char *filename, Oid lobjId);
также импортирует новый большой объект. В lobjId можно задать назначаемый ему OID; при этом произойдёт ошибка, если этот OID уже присвоен какому-либо большому объекту. Если в lobjId передаётся InvalidOid (ноль), lo_import_with_oid присваивает большому объекту свободный OID (так же, как и lo_import). Возвращаемым значением будет OID, назначенный новому большому объекту, либо InvalidOid (ноль) в случае ошибки.
Функция lo_import_with_oid появилась в PostgreSQL 8.4 и вызывает внутри lo_create, появившуюся в 8.1; если попытаться выполнить её с сервером версии 8.0 или ранней, она завершится ошибкой и возвратит InvalidOid.
34.3.3. Экспорт большого объекта #
Чтобы экспортировать большой объект в файл операционной системы, вызовите
int lo_export(PGconn *conn, Oid lobjId, const char *filename);
В аргументе lobjId задаётся OID экспортируемого большого объекта, а в аргументе filename задаётся имя файла в операционной системе. Заметьте, что файл записывается библиотекой клиентского интерфейса, а не сервером. Возвращает 1 при успешном выполнении, -1 при ошибке.
34.3.4. Открытие существующего большого объекта #
Чтобы открыть существующий большой объект для чтения или записи, вызовите
int lo_open(PGconn *conn, Oid lobjId, int mode);
В аргументе lobjId задаётся OID открываемого большого объекта. Биты в аргументе mode определяют, открывается ли файл для чтения (INV_READ), для записи (INV_WRITE), либо для чтения/записи. (Эти константы определяются в заголовочном файле libpq/libpq-fs.h.) Функция lo_open возвращает дескриптор большого объекта (неотрицательный) для последующего использования в функциях lo_read, lo_write, lo_lseek, lo_lseek64, lo_tell, lo_tell64, lo_truncate, lo_truncate64 и lo_close. Этот дескриптор актуален только до завершения текущей транзакции. В случае ошибки возвращается -1.
В настоящее время сервер не различает режимы INV_WRITE и INV_READ | INV_WRITE: с таким дескриптором можно читать данные в любом случае. Однако есть значительное отличие этих режимов от одиночного INV_READ: с дескриптором INV_READ записывать данные нельзя, а данные, считываемые через него, будут отражать содержимое большого объекта в снимке транзакции, который был активен при выполнении lo_open, то есть не будут включать изменения, произведённые позже этой или другими транзакциями. При чтении с дескриптором INV_WRITE возвращаются данные, отражающие все изменения, произведённые другими зафиксированными транзакциями, а также текущей транзакцией. Это подобно различиям режимов REPEATABLE READ и READ COMMITTED для обычных команд SQL SELECT.
Функция lo_open завершится ошибкой, если пользователь не имеет права SELECT для данного большого объекта или если указан флаг INV_WRITE и отсутствует право UPDATE. (До PostgreSQL 11 права проверялись при первом фактическом вызове функции чтения или записи с этим дескриптором.) Отключить новые проверки можно с помощью параметра времени выполнения lo_compat_privileges.
Пример:
inv_fd = lo_open(conn, inv_oid, INV_READ|INV_WRITE);
34.3.5. Запись данных в большой объект #
int lo_write(PGconn *conn, int fd, const char *buf, size_t len);
записывает len байт из буфера buf (который должен иметь размер len) в дескриптор большого объекта fd. В fd должно передаваться значение, возвращённое предыдущим вызовом lo_open. Возвращает эта функция число фактически записанных байт (в текущей реализации это всегда len, если только не произошла ошибка). В случае ошибки возвращается значение -1.
Хотя параметр len объявлен как size_t, эта функция не принимает значение длины, превышающее INT_MAX. На практике всё равно лучше передавать данные фрагментами не больше нескольких мегабайт.
34.3.6. Чтение данных из большого объекта #
int lo_read(PGconn *conn, int fd, char *buf, size_t len);
читает до len байт из дескриптора большого объекта fd в буфер buf (который должен иметь размер len). В fd должно передаваться значение, возвращённое предыдущим вызовом lo_open. Возвращает эта функция число фактически прочитанных байт; это число должно быть меньше len, если при чтении был достигнут конец объекта. В случае ошибки возвращается -1.
Хотя параметр len объявлен как size_t, эта функция не принимает значение длины, превышающее INT_MAX. На практике всё равно лучше передавать данные фрагментами не больше нескольких мегабайт.
34.3.7. Перемещение в большом объекте #
Чтобы изменить текущее положение чтения или записи, связанное с дескриптором большого объекта, вызовите
int lo_lseek(PGconn *conn, int fd, int offset, int whence);
Эта функция перемещает указатель текущего положения для дескриптора большого объекта fd в новое положение, заданное аргументом offset. Для аргумента whence задаются значения SEEK_SET (перемещение от начала объекта), SEEK_CUR (перемещение от текущего положения) и SEEK_END (перемещение от конца объекта). Возвращает эта функция новое положение указателя, либо -1 в случае ошибки.
Оперируя большими объектами, размер которых превышает 2 ГБ, используйте
int64_t lo_lseek64(PGconn *conn, int fd, int64_t offset, int whence);
Эта функция действует так же, как и lo_lseek, но может принять значение offset, превышающее 2 ГБ, и/или вернуть результат, превышающий 2 ГБ. Заметьте, что если новое положение указателя оказывается за границей в 2ГБ, функция lo_lseek выдаёт ошибку.
Функция lo_lseek64 появилась в PostgreSQL 9.3. Если попытаться выполнить её с сервером более старой версии, произойдёт ошибка и будет возвращено -1.
34.3.8. Получение текущего положения в большом объекте #
Чтобы получить текущее положение чтения или записи для дескриптора большого объекта, вызовите
int lo_tell(PGconn *conn, int fd);
Если возникает ошибка, возвращается -1.
Оперируя большими объектами, размер которых может превышать 2 ГБ, используйте
int64_t lo_tell64(PGconn *conn, int fd);
Эта функция действует так же, как lo_tell, но может выдавать результат, превышающий 2 ГБ. Заметьте, что lo_tell выдаёт ошибку, если текущее положение чтения/записи оказывается за границей в 2 ГБ.
Функция lo_tell64 появилась в PostgreSQL 9.3. Если попытаться выполнить её с сервером более старой версии, произойдёт ошибка и будет возвращено -1.
34.3.9. Усечение большого объекта #
Чтобы усечь большой объект до требуемой длины, вызовите
int lo_truncate(PGconn *conn, int fd, size_t len);
Эта функция усекает большой объект с дескриптором fd до длины len. В fd должно передаваться значение, возвращённое предыдущим вызовом lo_open. Если len превышает текущую длину большого объекта, большой объект расширяется до заданной длины нулевыми байтами ('\0'). В случае успеха lo_truncate возвращает ноль, а при ошибке возвращается -1.
Положение чтения/записи, связанное с дескриптором fd, при этом не меняется.
Хотя параметр len объявлен как size_t, lo_truncate не принимает значение длины, превышающее INT_MAX.
Оперируя большими объектами, размер которых может превышать 2 ГБ, используйте
int lo_truncate64(PGconn *conn, int fd, int64_t len);
Эта функция действует так же, как lo_truncate, но может принимать значения len, превышающие 2 ГБ.
Функция lo_truncate появилась в PostgreSQL 8.3; если попытаться выполнить её с сервером более старой версии, произойдёт ошибка и будет возвращено -1.
Функция lo_truncate64 появилась в PostgreSQL 9.3; если попытаться выполнить её с сервером более старой версии, произойдёт ошибка и будет возвращено -1.
34.3.10. Закрытие дескриптора большого объекта #
Дескриптор большого объекта можно закрыть, вызвав
int lo_close(PGconn *conn, int fd);
Здесь fd — дескриптор большого объекта, возвращённый функцией lo_open. В случае успеха lo_close возвращает ноль. При ошибке возвращается -1.
Все дескрипторы больших объектов, остающиеся открытыми в конце транзакции, закрываются автоматически.
34.3.11. Удаление большого объекта #
Чтобы удалить большой объект из базы данных, вызовите
int lo_unlink(PGconn *conn, Oid lobjId);
В аргументе lobjId задаётся OID большого объекта, который нужно удалить. В случае успеха возвращается 1, а в случае ошибки -1.
34.3. Client Interfaces #
- 34.3.1. Creating a Large Object
- 34.3.2. Importing a Large Object
- 34.3.3. Exporting a Large Object
- 34.3.4. Opening an Existing Large Object
- 34.3.5. Writing Data to a Large Object
- 34.3.6. Reading Data from a Large Object
- 34.3.7. Seeking in a Large Object
- 34.3.8. Obtaining the Seek Position of a Large Object
- 34.3.9. Truncating a Large Object
- 34.3.10. Closing a Large Object Descriptor
- 34.3.11. Removing a Large Object
- 34.3.2. Importing a Large Object
This section describes the facilities that Postgres Pro's libpq client interface library provides for accessing large objects. The Postgres Pro large object interface is modeled after the Unix file-system interface, with analogues of open, read, write, lseek, etc.
All large object manipulation using these functions must take place within an SQL transaction block, since large object file descriptors are only valid for the duration of a transaction. Write operations, including lo_open with the INV_WRITE mode, are not allowed in a read-only transaction.
If an error occurs while executing any one of these functions, the function will return an otherwise-impossible value, typically 0 or -1. A message describing the error is stored in the connection object and can be retrieved with PQerrorMessage .
Client applications that use these functions should include the header file libpq/libpq-fs.h and link with the libpq library.
Client applications cannot use these functions while a libpq connection is in pipeline mode.
34.3.1. Creating a Large Object #
Oid lo_create(PGconn *conn, Oid lobjId);
creates a new large object. The OID to be assigned can be specified by lobjId; if so, failure occurs if that OID is already in use for some large object. If lobjId is InvalidOid (zero) then lo_create assigns an unused OID. The return value is the OID that was assigned to the new large object, or InvalidOid (zero) on failure.
An example:
inv_oid = lo_create(conn, desired_oid);
Oid lo_creat(PGconn *conn, int mode);
also creates a new large object, always assigning an unused OID. The return value is the OID that was assigned to the new large object, or InvalidOid (zero) on failure.
In PostgreSQL releases 8.1 and later, the mode is ignored, so that lo_creat is exactly equivalent to lo_create with a zero second argument. However, there is little reason to use lo_creat unless you need to work with servers older than 8.1. To work with such an old server, you must use lo_creat not lo_create, and you must set mode to one of INV_READ, INV_WRITE, or INV_READ | INV_WRITE. (These symbolic constants are defined in the header file libpq/libpq-fs.h.)
An example:
inv_oid = lo_creat(conn, INV_READ|INV_WRITE);
34.3.2. Importing a Large Object #
To import an operating system file as a large object, call
Oid lo_import(PGconn *conn, const char *filename);
filename specifies the operating system name of the file to be imported as a large object. The return value is the OID that was assigned to the new large object, or InvalidOid (zero) on failure. Note that the file is read by the client interface library, not by the server; so it must exist in the client file system and be readable by the client application.
Oid lo_import_with_oid(PGconn *conn, const char *filename, Oid lobjId);
also imports a new large object. The OID to be assigned can be specified by lobjId; if so, failure occurs if that OID is already in use for some large object. If lobjId is InvalidOid (zero) then lo_import_with_oid assigns an unused OID (this is the same behavior as lo_import). The return value is the OID that was assigned to the new large object, or InvalidOid (zero) on failure.
lo_import_with_oid is new as of PostgreSQL 8.4 and uses lo_create internally which is new in 8.1; if this function is run against 8.0 or before, it will fail and return InvalidOid.
34.3.3. Exporting a Large Object #
To export a large object into an operating system file, call
int lo_export(PGconn *conn, Oid lobjId, const char *filename);
The lobjId argument specifies the OID of the large object to export and the filename argument specifies the operating system name of the file. Note that the file is written by the client interface library, not by the server. Returns 1 on success, -1 on failure.
34.3.4. Opening an Existing Large Object #
To open an existing large object for reading or writing, call
int lo_open(PGconn *conn, Oid lobjId, int mode);
The lobjId argument specifies the OID of the large object to open. The mode bits control whether the object is opened for reading (INV_READ), writing (INV_WRITE), or both. (These symbolic constants are defined in the header file libpq/libpq-fs.h.) lo_open returns a (non-negative) large object descriptor for later use in lo_read, lo_write, lo_lseek, lo_lseek64, lo_tell, lo_tell64, lo_truncate, lo_truncate64, and lo_close. The descriptor is only valid for the duration of the current transaction. On failure, -1 is returned.
The server currently does not distinguish between modes INV_WRITE and INV_READ | INV_WRITE: you are allowed to read from the descriptor in either case. However there is a significant difference between these modes and INV_READ alone: with INV_READ you cannot write on the descriptor, and the data read from it will reflect the contents of the large object at the time of the transaction snapshot that was active when lo_open was executed, regardless of later writes by this or other transactions. Reading from a descriptor opened with INV_WRITE returns data that reflects all writes of other committed transactions as well as writes of the current transaction. This is similar to the behavior of REPEATABLE READ versus READ COMMITTED transaction modes for ordinary SQL SELECT commands.
lo_open will fail if SELECT privilege is not available for the large object, or if INV_WRITE is specified and UPDATE privilege is not available. (Prior to PostgreSQL 11, these privilege checks were instead performed at the first actual read or write call using the descriptor.) These privilege checks can be disabled with the lo_compat_privileges run-time parameter.
An example:
inv_fd = lo_open(conn, inv_oid, INV_READ|INV_WRITE);
34.3.5. Writing Data to a Large Object #
int lo_write(PGconn *conn, int fd, const char *buf, size_t len);
writes len bytes from buf (which must be of size len) to large object descriptor fd. The fd argument must have been returned by a previous lo_open. The number of bytes actually written is returned (in the current implementation, this will always equal len unless there is an error). In the event of an error, the return value is -1.
Although the len parameter is declared as size_t, this function will reject length values larger than INT_MAX. In practice, it's best to transfer data in chunks of at most a few megabytes anyway.
34.3.6. Reading Data from a Large Object #
int lo_read(PGconn *conn, int fd, char *buf, size_t len);
reads up to len bytes from large object descriptor fd into buf (which must be of size len). The fd argument must have been returned by a previous lo_open. The number of bytes actually read is returned; this will be less than len if the end of the large object is reached first. In the event of an error, the return value is -1.
Although the len parameter is declared as size_t, this function will reject length values larger than INT_MAX. In practice, it's best to transfer data in chunks of at most a few megabytes anyway.
34.3.7. Seeking in a Large Object #
To change the current read or write location associated with a large object descriptor, call
int lo_lseek(PGconn *conn, int fd, int offset, int whence);
This function moves the current location pointer for the large object descriptor identified by fd to the new location specified by offset. The valid values for whence are SEEK_SET (seek from object start), SEEK_CUR (seek from current position), and SEEK_END (seek from object end). The return value is the new location pointer, or -1 on error.
When dealing with large objects that might exceed 2GB in size, instead use
int64_t lo_lseek64(PGconn *conn, int fd, int64_t offset, int whence);
This function has the same behavior as lo_lseek, but it can accept an offset larger than 2GB and/or deliver a result larger than 2GB. Note that lo_lseek will fail if the new location pointer would be greater than 2GB.
lo_lseek64 is new as of PostgreSQL 9.3. If this function is run against an older server version, it will fail and return -1.
34.3.8. Obtaining the Seek Position of a Large Object #
To obtain the current read or write location of a large object descriptor, call
int lo_tell(PGconn *conn, int fd);
If there is an error, the return value is -1.
When dealing with large objects that might exceed 2GB in size, instead use
int64_t lo_tell64(PGconn *conn, int fd);
This function has the same behavior as lo_tell, but it can deliver a result larger than 2GB. Note that lo_tell will fail if the current read/write location is greater than 2GB.
lo_tell64 is new as of PostgreSQL 9.3. If this function is run against an older server version, it will fail and return -1.
34.3.9. Truncating a Large Object #
To truncate a large object to a given length, call
int lo_truncate(PGconn *conn, int fd, size_t len);
This function truncates the large object descriptor fd to length len. The fd argument must have been returned by a previous lo_open. If len is greater than the large object's current length, the large object is extended to the specified length with null bytes ('\0'). On success, lo_truncate returns zero. On error, the return value is -1.
The read/write location associated with the descriptor fd is not changed.
Although the len parameter is declared as size_t, lo_truncate will reject length values larger than INT_MAX.
When dealing with large objects that might exceed 2GB in size, instead use
int lo_truncate64(PGconn *conn, int fd, int64_t len);
This function has the same behavior as lo_truncate, but it can accept a len value exceeding 2GB.
lo_truncate is new as of PostgreSQL 8.3; if this function is run against an older server version, it will fail and return -1.
lo_truncate64 is new as of PostgreSQL 9.3; if this function is run against an older server version, it will fail and return -1.
34.3.10. Closing a Large Object Descriptor #
A large object descriptor can be closed by calling
int lo_close(PGconn *conn, int fd);
where fd is a large object descriptor returned by lo_open. On success, lo_close returns zero. On error, the return value is -1.
Any large object descriptors that remain open at the end of a transaction will be closed automatically.
34.3.11. Removing a Large Object #
To remove a large object from the database, call
int lo_unlink(PGconn *conn, Oid lobjId);
The lobjId argument specifies the OID of the large object to remove. Returns 1 if successful, -1 on failure.
