Postgres grande objeto

Objetos grandes (lobs) são aquelas coleções de tipos de dados criadas para conter uma grande quantidade de dados até um tamanho máximo que varia de 8 terabytes a 128 terabytes. Depende principalmente da configuração de um banco de dados.

Por que objetos grandes são usados ​​no PostgreSQL

Explicaremos diferentes tipos de dados adequados para objetos grandes e seu objetivo de criação.

• Dados estruturados: Este é um tipo simples de dados estruturados e pode ser criado em uma tabela simples.
• Dados estruturados complexos: Essas são estruturas complexas e são criadas para gerenciar os recursos da Relacional de Objetos do banco de dados Oracle, como coleções e referências.
• Dados não estruturados: Esses tipos de dados não são interpretados pelo banco de dados e esses tipos de dados não são divididos em estruturas lógicas menores.

Sintaxe

# Criar tabela tabela_name (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

Uma tabela para um objeto grande é criada com o tipo de dados de uma coluna específica com um bytea ou blob para armazenar os valores para um objeto grande, como imagens ou vídeos.

Implementação

Criaremos uma tabela com o tipo de blob de dados em uma coluna, enquanto outras colunas têm tipos de dados inteiros e varchar. Mas, na execução de uma consulta, isso causa um erro ao exibir que o tipo 'Blob' não existe.

>> Crie tabela tbl_blob (tbl_blob blob, id inteiro, nome varchar (10), endereço varchar (10));

Criaremos os mesmos atributos de tabela novamente, tendo a primeira coluna com o tipo de dados de 'bytea'. Este também é um tipo de variável de dados do tipo blob. Ao usar isso, podemos restaurar os dados do tipo binário no PostgreSQL.

>> Crie tabela tbl_blob (tbl_blob bytea, id inteiro, nome varchar (10), endereço varchar (10));

Isso foi feito para mostrar a diferença no uso de blob e bytea. Na maioria das vezes, o BLOB não é compatível com algumas versões do PostgreSQL; É por isso que usamos bytea no comando.

Uma nova tabela de amostra será criada novamente para testar o uso do grande objeto. Uma tabela chamada tbl_blob1 é criada.

>> Crie Tabela Tbl_blob1 (Tbl_blob Bytea, ID inteiro, nome Varchar (10), endereço Varchar (10), classe

varchar (10)); [/cc]

Depois de criar a tabela, agora veremos a descrição da tabela para observar o tipo de armazenamento e os tipos de coluna.

>> \ d+ tbl_blol1;

Você pode ver na imagem acima que os nomes da coluna e o tipo de dados são exibidos. O método usado para acessar esta descrição é o tipo de heap. Para explicar o uso de objetos grandes em mais de uma coluna, criaremos novamente uma tabela. Esta tabela conterá mais de uma coluna com o tipo de dados de objeto grande.

>> Crie a tabela tbl_blob2 (tbl_blob bytea, tbl1_blob bytea, tbl2_blob bytea, id inteiro, nome varchar (10), endereço varchar (10), classe varchar (10));

Após a criação, use novamente o comando escrito abaixo para ver a descrição da tabela.

>> \ d+ tbl_blob2;

Até agora, vimos o uso de blob enquanto criava a mesa. Mas, para adicionar uma nova coluna com um tipo de dados de bytea e blob, precisamos de um comando de atualização. Na Tabela Tbl_blob1, adicionamos uma coluna chamada TBL1_BLOB que possui o tipo de dados de bytea.

>> ALTER TABELA TBL_BLOB1 Adicione a coluna TBL1_BLOB BYTEA;

Criação de objetos grande em PostgreSQL

Existe uma função para criar um objeto grande.

# Oid lo_creat (PGConn *CON, int Mode);

Nesta função, 'modo' é uma máscara de bits que é usada para descrever diferentes atributos do objeto que é criado recentemente. Enquanto as constantes usadas na função estão presentes na Biblioteca do Arquivo de Cabeçalho Libpq-Fs. Aqui, aplicamos um exemplo de amostra para a criação de objetos grandes, na qual o valor é retornado e aceito por uma variável.

# inv_oid = lo_creat (inv_read | inv_write);

A leitura e a gravação são os tipos de acesso usados ​​na função. Um argumento "-1" é usado como um parâmetro da função lo_creat () para criar um grande objeto no exemplo dado. Isso é usado para criar um novo grande, vazio, mostrando o índice como nulo.

>> selecione lo-_creat (-1);

Um valor aleatório é atribuído pelo PostgreSQL. Para fornecer um valor específico para criar um objeto grande, fornecemos um valor de nossa própria escolha no parâmetro.

>> selecione Lo_create (9945621);

Importar objeto grande

Se você deseja importar um arquivo presente em qualquer diretório do seu sistema operacional como um objeto grande, isso pode ser usado como uma chamada de função.

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

Name_of_file é o arquivo específico que você deseja importar do sistema como um objeto grande. O valor OID que é atribuído a um novo objeto grande é o valor retornado.

Exportar um grande objeto

Ao contrário da importação, objetos grandes também podem ser exportados para o sistema operacional. Uma chamada de função para exportar o objeto grande é feita.

# Int lo_export (pgcon *conn, lobjid, constante char *name_of_file);

OID é mostrado por lobjid. OID é especificado para o objeto que precisa ser exportado do PostgreSQL para o sistema operacional. O argumento do nome do arquivo é que ele especifica o nome do sistema operacional. Um grande ID de objeto é criado para apoiar a exportação do arquivo do PostgreSQL para o sistema operacional.

Abra um objeto grande que já existe no PostgreSQL

Se você deseja abrir um grande detalhe do objeto que já está presente e criado antes no PostgreSQL, a seguinte função é usada.

# Int lo_open (PGCON *CON, OID LOJID, INT MODE);

O objeto grande é aberto para qualquer finalidade como ler ou escrever ou para ambos, qualquer atualização pode ser feita. 'lo_open' uma variável do tipo inteiro, retorna o objeto grande para uso posterior em lo_write, lo_read ou lo_close.

Escrevendo/lendo dados de/para o grande objeto

Escreva dados para grande objeto

# Int lo_write (pgcon *conn, int fx, const char *buffr, size_t lenn);

O grande objeto FX é usado para escrever no comprimento de Lenn da Buffer Buffr. Os bytes escritos são devolvidos. Se o valor de retorno for negativo, isso significa que ocorreu um erro.

Leia os dados

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

Esta função lê os bytes de comprimento de Lenn do grande objeto em um buffer buffr. O valor é retornado como o processo de escrita.

Remoção de objetos grande

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

Usamos o exemplo abaixo do citado usando um comando select com um número OID. O 'lo_unlink' é usado para remover o OID.

>> selecione lo_unlink (9945621);

Implementar grandes comandos de objeto

Usaremos algumas das características acima mencionadas de um grande objeto no shell psql. O primeiro comando CREATE é usado para criar uma tabela do objeto grande ao fazer isso acima.

>> Crie pic tabela (ID Integer, Nome Text, Pic Oid);

Aqui a tabela é criada para armazenar as informações de uma imagem com o tipo de dados de ID de objeto grande.

Insira valores na tabela

>> inserir em valores de pic (id, nome, pic) (1, 'minha imagem', lo_import ('/etc1/mottd'));

Uma imagem do sistema operacional é selecionada aqui.

Conclusão

O artigo 'Postgres grande objeto' contém a descrição da especialidade de usar o objeto grande, seus tipos e algumas funções importantes usadas na criação, importação e exportação de objetos PostGresql. Alguns dos recursos são implementados no shell PostgreSQL para elaborar a criação e o trabalho de objetos grandes para armazenar dados.