Documentação do PostgreSQL 7.4.1
Anterior	Início	Capítulo 31. A interface JDBC	Fim	Próxima

31.8. Extensões do PostgreSQL à API JDBC

O PostgreSQL é um sistema de banco de dados extensível. Os usuários podem adicionar ao servidor funções que podem ser chamadas nas consultas, e até mesmo adicionar tipos de dado. Como estas facilidades existem apenas no PostgreSQL, as mesmas são suportadas no Java através de um conjunto de APIs de extensão. Algumas funcionalidades dentro do núcleo do driver padrão usam estas extensões para implementar Objetos Grandes, etc.

31.8.1. Acesso às extensões

Para acessar algumas das extensões é necessário utilizar alguns métodos extras da classe org.postgresql.PGConnection. Neste caso, será necessário transformar o valor retornado por Driver.getConnection(). Por exemplo:

Connection db = Driver.getConnection(url, nome_do_usuário, senha);
// ...
// depois
Fastpath fp = ((org.postgresql.PGConnection)db).getFastpathAPI();

31.8.1.1. Classe `org.postgresql.PGConnection`

public class PGConnection

Abaixo estão os métodos extra utilizados para obter acesso às extensões do PostgreSQL.

31.8.1.1.1. Métodos

```
public Fastpath getFastpathAPI() throws SQLException
```
Retorna a API de caminho rápido (fast-path) para a conexão corrente. É utilizada principalmente pela API LargeObject. A melhor forma de utilizar é a mostrada a seguir:
```
import org.postgresql.fastpath.*;
...
Fastpath fp = ((org.postgresql.PGConnection)conn).getFastpathAPI();
```
onde conn é uma Connection com o PostgreSQL aberta.
Retorna: O objeto Fastpath que permite acessar funções no servidor PostgreSQL.

Lança: SQLException por Fastpath ao inicializar pela primeira vez
```
public LargeObjectManager getLargeObjectAPI() throws SQLException
```
Retorna a API LargeObject para a conexão corrente. A melhor forma de utilizar é a mostrada a seguir:
```
import org.postgresql.largeobject.*;
...
LargeObjectManager lo = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();
```
onde conn é uma Connection com o PostgreSQL aberta.
Retorna: O objeto LargeObject que implementa a API

Lança: SQLException por LargeObject ao inicializar pela primeira vez
```
public void addDataType(String tipo, String nome)
```
Permite o código cliente adicionar tratador para um dos tipos de dado únicos do PostgreSQL. Normalmente, um tipo de dado desconhecido pelo driver é retornado por ResultSet.getObject() como uma instância de PGobject. Este método permite escrever uma classe que estende PGobject, e informar ao driver o nome do tipo e o nome da classe a ser utilizada. O problema é que este método deve ser chamado toda vez que for feita uma conexão. A melhor forma de utilizar é a mostrada a seguir:
```
 ...
((org.postgresql.PGConnection)conn).addDataType("meu_tipo","minha.classe.nome");
 ...
```
onde conn é uma Connection aberta com o PostgreSQL. A classe tratadora deve estender org.postgresql.util.PGobject.

31.8.1.2. Classe `org.postgresql.Fastpath`

public class Fastpath extends Object

java.lang.Object
   |
   +----org.postgresql.fastpath.Fastpath

Fastpath é uma API que existe dentro da interface C da libpq, que permite a máquina cliente executar funções no servidor de banco de dados. A maior parte dos códigos cliente não precisa utilizar este método, mas é fornecido porque é utilizado pela API LargeObject.

Para usá-lo é necessário importar o pacote org.postgresql.fastpath, utilizando a linha:

import org.postgresql.fastpath.*;

Depois, no código, é necessário obter um objeto FastPath:

Fastpath fp = ((org.postgresql.PGConnection)conn).getFastpathAPI();

A linha acima retorna uma instância associada à conexão com o banco de dados, que pode ser utilizada para executar comandos. A conversão de Connection em org.postgresql.PGConnection é necessária, porque getFastpathAPI() é um método de extensão, e não parte do JDBC. Uma vez obtida uma instância de Fastpath, podem ser utilizados os métodos fastpath() para executar uma função do servidor.

Veja também: FastpathFastpathArg, LargeObject

31.8.1.2.1. Métodos

```
public Object fastpath(int fnid,
                       boolean resulttype,
                       FastpathArg args[]) throws SQLException
```
Envia uma chamada de função para o servidor PostgreSQL.
Parâmetros: fnid - Identificador da função; resulttype - Verdade se o resultado for um inteiro, falso para os outros resultados; args - FastpathArguments a serem passados para a chamada de fast-path.

Retorna: nulo se não houver dado, Integer para um resultado inteiro, ou byte[] nos demais casos.
```
public Object fastpath(String nome,
                       boolean resulttype,
                       FastpathArg args[]) throws SQLException
```
Envia uma chamada para o servidor PostgreSQL por nome.

Nota: O mapeamento entre nome de procedimento e identificador de função precisa existir, geralmente é feito através de uma chamada prévia a addfunction(). Este é o método preferido para chamar, porque os identificadores de função podem mudar entre versões do servidor. Para ver um exemplo mostrando como funciona, consulte org.postgresql.LargeObject

Parâmetros: nome - Nome da função; resulttype - Verdade se o resultado for um inteiro, falso para os outros resultados; args - FastpathArguments a serem passados para a chamada de fast-path.

Retorna: nulo se não houver dado, Integer para um resultado inteiro, ou byte[] nos demais casos.

Veja também: LargeObject
```
public int getInteger(String nome,
                      FastpathArg args[]) throws SQLException
```
Este método assume que o valor retornado é um Integer
Parâmetros: nome - Nome da função args - Argumentos da função

Retorna: resultado inteiro

Lança: SQLException se ocorrer um erro de acesso ao banco de dados ou não houver resultado
```
public byte[] getData(String nome,
                      FastpathArg args[]) throws SQLException
```
Este método assume que o valor retornado é binário
Parâmetros: nome - Nome da função args - Argumentos da função

Retorna: matriz byte[] contendo o resultado

Lança: SQLException se ocorrer um erro de acesso ao banco de dados ou não houver resultado
```
public void addFunction(String nome,
                        int fnid)
```
Adiciona uma função à tabela de procura. Pode ser utilizado o método addFunctions, que tem por base uma consulta, em vez de especificar diretamente o OID. Não há garantia que o OID da função permaneça estático, mesmo entre servidores diferentes com a mesma versão.
```
public void addFunctions(ResultSet rs) throws SQLException
```
Recebe um ResultSet contendo duas colunas. A coluna 1 contém o nome da função e a coluna 2 o OID. Todo o ResultSet é lido e os valores são carregados na tabela de função.

Importante: Lembre-se de fechar (close()) o ResultSet após a chamada!

Notas de implementação sobre a procura de nome de função: O PostgreSQL armazena os identificadores das funções e seus nomes correspondentes na tabela pg_proc. Para acelerar o processamento local, em vez de consultar cada função na tabela toda vez que for necessário, é utilizada uma Hashtable. Também, somente as funções necessárias são colocadas nesta tabela, tornando o tempo de conexão o mais rápido possível. A classe org.postgresql.LargeObject realiza a consulta ao ser inicializada, e passa o ResultSet retornado para o método addFunctions(). Após o término, a API LargeObject faz referência às funções por nome. Não se deve supor que vai funcionar se forem convertidos manualmente nos OIDs. Está certo, por ora funcionam, mas podem mudar durante o desenvolvimento (existia alguma explicação sobre este assunto para a versão V7.0) e, portanto, isto é implementado para prevenir contra dores de cabeça futuras.

Veja também: LargeObjectManager
```
public int getID(String nome) throws SQLException
```
Retorna o identificador de função associado a partir do nome. Se addFunction() ou addFunctions() ainda não tiver sido chamada para este nome, então é lançada uma exceção SQLException.

31.8.1.3. Classe `org.postgresql.fastpath.FastpathArg`

public class FastpathArg extends Object

java.lang.Object
   |
   +----org.postgresql.fastpath.FastpathArg

Cada chamada de fast-path requer uma matriz de argumentos, o número e o tipo dependendo da função sendo chamada. Esta classe implementa os métodos necessários para fornecer esta capacidade.

Para ver um exemplo de sua utilização consulte o pacote org.postgresql.LargeObject.

Veja também: Fastpath, LargeObjectManager, LargeObject

31.8.1.3.1. Construtores

```
public FastpathArg(int valor)
```
Constrói um argumento que consiste em um valor inteiro
Parâmetros: valor - valor inteiro a ser definido
```
public FastpathArg(byte bytes[])
```
Constrói um argumento que consiste em uma matriz de bytes
Parâmetros: bytes - matriz para armazenar
```
public FastpathArg(byte buf[],
                   int off,
                   int len)
```
Constrói um argumento que consiste em uma parte de uma matriz de bytes
Parâmetros:

buf

matriz fonte

off

deslocamento dentro da matriz

len

comprimento dos dados a serem incluídos
```
public FastpathArg(String s)
```
Constrói um argumento que consiste em uma cadeia de caracteres.

31.8.2. Tipos de dado geométricos

O PostgreSQL possui um conjunto de tipos de dado que podem armazenar características geométricas em uma tabela. Fazem parte pontos, linhas e polígonos. Estes tipos são suportados no Java através do pacote org.postgresql.geometric, que contém classes que estendem a classe org.postgresql.util.PGobject. Consulte esta classe para obter detalhes sobre como implementar seus próprios tratadores de tipo de dado.

Class org.postgresql.geometric.PGbox

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGbox

   public class PGbox extends PGobject implements Serializable,
Cloneable

        Representa o tipo de dado caixa no PostgreSQL.

Variáveis

 public PGpoint point[]

        Dois pontos do canto da caixa.

Construtores

 public PGbox(double x1,
              double y1,
              double x2,
              double y2)

        Parâmetros:
                x1 - primeira coordenada x
                y1 - primeira coordenada y
                x2 - segunda coordenada x
                y2 - segunda coordenada y

 public PGbox(PGpoint p1,
              PGpoint p2)

        Parâmetros:
                p1 - primeiro ponto
                p2 - segundo ponto

 public PGbox(String s) throws SQLException

        Parâmetros:
                s - definição da caixa na sintaxe do PostgreSQL

        Lança: SQLException
                se a definição não for válida

 public PGbox()

        Construtor requerido

Métodos

 public void setValue(String valor) throws SQLException

        Este método define o valor deste objeto. Deve ser sobreposta,
        mas ainda chamada por subclasses.

        Parâmetros:
                valor - a representação do valor do objeto em uma cadeia de caracteres
        Lança: SQLException
                lançado se o valor for inválido para este tipo

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se as duas caixas forem idênticas

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna:
                PGbox na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

Class org.postgresql.geometric.PGcircle

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGcircle

   public class PGcircle extends PGobject implements Serializable,
Cloneable

        Representa o tipo de dado círculo do PostgreSQL,
        que consiste em um ponto e o raio

Variáveis

 public PGpoint center

        O ponto do centro

 double radius

        O raio

Construtores

 public PGcircle(double x,
                 double y,
                 double r)

        Parâmetros:
               x - coordenada do centro
               y - coordenada do centro
               r - raio do círculo

 public PGcircle(PGpoint c,
                 double r)

        Parâmetros:
                c - PGpoint descrevendo o centro do círculo
                r - raio do círculo

 public PGcircle(String s) throws SQLException

        Parâmetros:
                s - definição do círculo na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

 public PGcircle()

        Este construtor é utilizado pelo driver.

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - definição do círculo na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se os dois círculos forem idênticos

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna:
                PGcircle na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

Class org.postgresql.geometric.PGline

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGline

   public class PGline extends PGobject implements Serializable,
Cloneable

        Implementa uma linha consistindo em dois pontos. Atualmente linha
        ainda não está implementada no servidor, mas esta classe garante
        que quando for feito estaremos pronto para isso.

Variáveis

 public PGpoint point[]

        São os dois pontos.

Construtores

 public PGline(double x1,
               double y1,
               double x2,
               double y2)

        Parâmetros:
                x1 - coordenada do primeiro ponto
                y1 - coordenada do primeiro ponto
                x2 - coordenada do segundo ponto
                y2 - coordenada do segundo ponto

 public PGline(PGpoint p1,
               PGpoint p2)

        Parâmetros:
                p1 - primeiro ponto
                p2 - segundo ponto

 public PGline(String s) throws SQLException

        Parâmetros:
                s - definição da linha na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

 public PGline()

          requerido pelo driver

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - Definição do segmento de linha na sintaxe do PostgreSQL

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se as duas linhas fore idênticas

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna:
                PGline na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

Class org.postgresql.geometric.PGlseg

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGlseg

   public class PGlseg extends PGobject implements Serializable,
Cloneable

   Implementa lseg (segmento de linha) consistindo em dois pontos

Variáveis

 public PGpoint point[]

        Os dois pontos.

Construtores

 public PGlseg(double x1,
               double y1,
               double x2,
               double y2)

        Parâmetros:

                x1 - coordenada do primeiro ponto
                y1 - coordenada do primeiro ponto
                x2 - coordenada do segundo ponto
                y2 - coordenada do segundo ponto

 public PGlseg(PGpoint p1,
               PGpoint p2)

        Parâmetros:
                p1 - primeiro ponto
                p2 - segundo ponto

 public PGlseg(String s) throws SQLException

        Parâmetros:
                s - Definição do segmento de linha na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

 public PGlseg()

        requerido pelo driver

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - Definição do segmento de linha na sintaxe do PostgreSQL

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se os dois segmentos de linha forem idênticos

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
               clone na classe PGobject

 public String getValue()

        Retorna:
                PGlseg na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

Class org.postgresql.geometric.PGpath

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpath

   public class PGpath extends PGobject implements Serializable,
Cloneable

   Implementa o caminho (uma linha com vários segmentos,
que pode ser fechada)

Variáveis

 public boolean open

        Verdade se o caminho for aberto, falso se for fechado

 public PGpoint points[]

        Os pontos que definem o caminho

Construtores

 public PGpath(PGpoint points[],
               boolean open)

        Parâmetros:
                points - os PGpoints que definem o caminho
                open - Verdade se o caminho for aberto, falso se for fechado

 public PGpath()

        Requerido pelo driver

 public PGpath(String s) throws SQLException

        Parâmetros:
                s - definição do caminho na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - definição do caminho na sintaxe do PostgreSQL

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se os dois caminhos forem idênticos

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna o caminho na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

 public boolean isOpen()

        Retorna verdade se o caminho for aberto

 public boolean isClosed()

        Retorna verdade se o caminho for fechado

 public void closePath()

        Marca o caminho como fechado

 public void openPath()

        Marca o caminho como aberto

Class org.postgresql.geometric.PGpoint

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpoint

   public class PGpoint extends PGobject implements Serializable,
Cloneable

        Implementa a versão de java.awt.Point, exceto por utilizar
        precisão dupla para representar as coordenadas.

        Mapeia para o tipo de dado ponto do PostgreSQL.

Variáveis

 public double x

        coordenada X do ponto

 public double y

        coordenada Y do ponto

Construtores

 public PGpoint(double x,
                double y)

        Parâmetros:
                x - coordenada
                y - coordenada

 public PGpoint(String valor) throws SQLException

        Chamado principalmente pelos outros tipos geométricos,
quando o ponto está incorporado na sua definição.

        Parâmetros:
                valor - Definição do ponto na sintaxe do PostgreSQL

 public PGpoint()

        Requerido pelo driver

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - Definição do ponto na sintaxe do PostgreSQL

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se os dois pontos forem idênticos

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna:
                PGpoint na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

 public void translate(int x,
                       int y)

        Translação do ponto na quantidade especificada

        Parâmetros:
                x - quantidade inteira a ser adicionada ao eixo x
                y - quantidade inteira a ser adicionada ao eixo y

 public void translate(double x,
                       double y)

        Translação do ponto na quantidade especificada

        Parâmetros:
                x - quantidade em precisão dupla a ser adicionada ao eixo x
                y - quantidade em precisão dupla a ser adicionada ao eixo y

 public void move(int x,
                  int y)

        Move o ponto para as coordenadas fornecidas.

        Parâmetros:
                x - coordenada inteira
                y - coordenada inteira

public void move(double x,
                  double y)

        Move o ponto para as coordenadas fornecidas.

        Parâmetros:
                x - coordenada em precisão dupla
                y - coordenada em precisão dupla

 public void setLocation(int x,
                         int y)

        Move o ponto para as coordenadas fornecidas. Consulte
        java.awt.Point para obter a descrição

        Parâmetros:
                x - coordenada inteira
                y - coordenada inteira

        Veja também:
                Point

 public void setLocation(Point p)

        Move o ponto para as coordenadas java.awt.Point fornecidas. Consulte
        java.awt.Point para obter a descrição

        Parâmetros:
                p - Ponto para mover para

        Veja também:
                Point

Class org.postgresql.geometric.PGpolygon

java.lang.Object
   |
   +----org.postgresql.util.PGobject
           |
           +----org.postgresql.geometric.PGpolygon

   public class PGpolygon extends PGobject implements Serializable,
Cloneable

        Implementa o tipo de dado polígono no PostgreSQL.

Variáveis

 public PGpoint points[]

        Os pontos que definem o polígono

Construtores

 public PGpolygon(PGpoint points[])

        Cria um polígono utilizando uma matriz de PGpoints

        Parâmetros:
                points - os pontos que definem o polígono

 public PGpolygon(String s) throws SQLException

        Parâmetros:
                s - definição do polígono na sintaxe do PostgreSQL.

        Lança: SQLException
                na falha de conversão

 public PGpolygon()

        Requerido pelo driver

Métodos

 public void setValue(String s) throws SQLException

        Parâmetros:
                s - definição do polígono na sintaxe do PostgreSQL

        Lança: SQLException
                na falha de conversão

        Sobrepõe:
                setValue na classe PGobject

 public boolean equals(Object obj)

        Parâmetros:
                obj - Objeto a ser comparado

        Retorna:
                verdade se os dois polígonos forem idênticos

        Sobrepõe:
                equals na classe PGobject

 public Object clone()

        Deve ser sobreposta para permitir a clonagem do objeto

        Sobrepõe:
                clone na classe PGobject

 public String getValue()

        Retorna:
                PGpolygon na sintaxe esperada pelo PostgreSQL

        Sobrepõe:
                getValue na classe PGobject

31.8.3. Objetos Grandes

Os Objetos Grandes são suportados na especificação padrão do JDBC. Entretanto, a interface é limitada e a API fornecida pelo PostgreSQL permite o acesso aleatório ao conteúdo do objeto, como se fosse um arquivo local.

O pacote org.postgresql.largeobject fornece ao Java a interface C da API de objeto grande da libpq. Consiste em duas classes, LargeObjectManager, que trata da criação, abertura e exclusão de objetos grandes, e LargeObject que trata individualmente os objetos.

31.8.3.1. Class `org.postgresql.largeobject.LargeObject`

public class LargeObject extends Object

java.lang.Object
   |
   +----org.postgresql.largeobject.LargeObject

Esta classe implementa a interface de objeto grande do PostgreSQL.

Fornece os métodos básicos requeridos para executar a interface, mais um par de métodos que fornecem as classes InputStream e OutputStream para o objeto.

Normalmente, o código cliente utiliza os métodos de BLOB para acessar os objetos grandes.

Entretanto, algumas vezes é necessário acesso de baixo nível aos Objetos Grandes que não são suportados pela especificação do JDBC.

Consulte org.postgresql.largeobject.LargeObjectManager para ver como obter acesso aos Objetos Grandes, ou como criar um.

Veja também: LargeObjectManager

31.8.3.1.1. Variáveis

public static final int SEEK_SET: Indica uma procura a partir do início do arquivo
public static final int SEEK_CUR: Indica uma procura a partir da posição corrente
public static final int SEEK_END: Indica uma procura a partir do fim do arquivo

31.8.3.1.2. Métodos

```
public int getOID()
```
Retorna o OID deste LargeObject
```
public void close() throws SQLException
```
Este método fecha o objeto. Não devem ser chamados métodos do objeto após este método ter sido chamado.
```
public byte[] read(int len) throws SQLException
```
Lê alguns dados do objeto, retornando uma matriz de byte[]
```
public int read(byte buf[],
                 int off,
                 int len) throws SQLException
```
Lê alguns dados do objeto para dentro de uma matriz existente
Parâmetros:

buf

matriz de destino

off

deslocamento dentro da matriz

len

número de bytes a serem lidos

public void write(byte buf[]) throws SQLException

Escreve uma matriz em um objeto

```
public void write(byte buf[],
                  int off,
                  int len) throws SQLException
```
Escreve alguns dados da matriz no objeto
Parâmetros:

buf

matriz de destino

off

deslocamento dentro da matriz

len

número de bytes a serem escritos

31.8.3.2. Classe `org.postgresql.largeobject.LargeObjectManager`

public class LargeObjectManager extends Object

java.lang.Object
   |
   +----org.postgresql.largeobject.LargeObjectManager

Esta classe implementa a interface de objeto grande do PostgreSQL. Fornece métodos que permitem o código cliente criar, abrir e excluir objetos grandes no banco de dados. Ao se abrir um objeto, é retornada uma instância de org.postgresql.largeobject.LargeObject e, então, seus métodos permitem acessar o objeto.

Esta classe somente pode ser criada por org.postgresql.PGConnection. Para obter acesso a esta classe, deve ser utilizado o seguinte segmento de código:

import org.postgresql.largeobject.*;
Connection  conn;
LargeObjectManager lobj;
// ... código que abre a conexão...
lobj = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();

Normalmente, o código cliente utiliza os métodos de BLOB para acessar os objetos grandes.

Entretanto, algumas vezes é necessário acesso de baixo nível aos Objetos Grandes que não são suportados pela especificação do JDBC.

Consulte org.postgresql.largeobject.LargeObjectManager para ver como manipular o conteúdo dos Objetos Grandes.

31.8.3.2.1. Variáveis

public static final int WRITE: Este modo indica que se deseja escrever no objeto.
public static final int READ: Este modo indica que se deseja ler o objeto.
public static final int READWRITE: Este modo é o padrão. Indica que se deseja acesso de leitura e escrita no objeto grande.

31.8.3.2.2. Métodos

```
public LargeObject open(int oid) throws SQLException
```
Abre um objeto grande existente com base em seu OID. Este método assume que está sendo requerido acesso de READ e de WRITE (o padrão).
```
public LargeObject open(int oid,
                        int mode) throws SQLException
```
Abre um objeto grande existente com base em seu OID. Permite definir o método de acesso.
```
public int create() throws SQLException
```
Cria um objeto grande e retorna o seu OID. O padrão é READWRITE para atributos do novo objeto.
```
public int create(int mode) throws SQLException
```
Cria um objeto grande e retorna o seu OID. Define o modo de acesso.

public void delete(int oid) throws SQLException

Remove um objeto grande.

```
public void unlink(int oid) throws SQLException
```
Remove um objeto grande. É idêntico ao método acima. É fornecido porque a API C utiliza "unlink".

Anterior	Principal	Próxima
Armazenamento de dados binários	Acima	Utilização do driver em um ambiente Multithread ou Servlet