FIREBIRD MAESTRO

Crie, converta, migre e edite bancos de dados com esta excelente ferramenta:

 

 

Fonte: https://www.sqlmaestro.com/products/firebird/maestro/download/

Anúncios

Como implementar o Blockchain em JavaScript

Ouvimos falar sobre Bitcoin, Ethereum além de outras moedas praticamente todos os dias. 2017 afinal, foi o ano dascryptocurrencies.

Nesse post porém, não vou focar em nenhuma dessas moedas digitais. Mas sim na tecnologia por trás delas, que muitas pessoas dizem ser tão revolucionárias quanto a própria internet, o Blockchain.

A ideia é implementar passo-a-passo uma versão simplificada do Blockchain em JavaScript e ir explicando como essa tecnologia disruptiva funciona por baixo dos panos.

Então, continue lendo esse post para aprender:

  • O que é e como funciona o Blockchain
  • Proof of Work?
  • Pra que servem os Blocos
  • O que é Mineração

Introdução

O Blockchain parece uma tecnologia de outro mundo e gera muitas dúvidas. Apesar disso, é algo extremamente fácil de definir:

O Blockchain nada mais é do que um banco de dados aberto e distribuído.

Esse banco de dados é composto de Blocos. E todos esses Blocos são ligados entre si em uma sequência. Daí o nome, Blockchain (cadeia de blocos).

Além disso, esse banco de dados é imutável.
E faz sentido que seja.

Imagina se fosse possível que alguém intencionalmente modificasse sua conta. Agora os 10 Bitcoins que você possui viraram 1.

Blocos

Vamos começar a implementação pela parte mais fácil: os Blocos. A estrutura de um Bloco deve possuir os seguintes campos:

  • index
  • timestamp
  • hash
  • previousHash
  • data

Crédito: https://medium.com/@lhartikk/a-blockchain-in-200-lines-of-code-963cc1cc0e54

index e o timestamp são campos comuns em praticamente todos bancos de dados. O campo data serve principalmente pra guardar transações mas podemos também colocar outras informações. O hash é calculado internamente e serve pra manter a integridade de cada Bloco e a segurança de todo o sistema (como vamos ver no final do post). E por final, o previousHash é o elo de ligação que liga cada Bloco ao seu Bloco anterior.

Com isso, temos a primeira implementação de um Bloco:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.hash = this.generateHash()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp).toString()
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

A função generateHash usa a biblioteca externa crypto-js pra gerar o hash seguindo o padrão sha256.

Parece complicado, mas tudo o que você precisa saber é que essa função vai receber uma string como por exemplo:

foo

E vai retornar uma string encriptada:

2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae

Blockchain

Agora que já temos uma versão mínima de um Bloco, já podemos começar a construir o Blockchain, que como falei anteriormente é uma sequência de Blocos ligados entre si.

Com isso, essa é a primeira versão do Blockchain:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

No construtor da classe, temos o array de Blocos inicializado já com o Genesis Block (o primeiro bloco criado no registro do Bitcoin). Adicionei também o index para poder incrementar toda vez que um novo Bloco for adicionado no Blockchain.

Além disso duas funções foram criadas:

  • getLastBlock
  • addBlock

A primeira é extremamente simples, ela serve pra pegar o último Bloco que foi criado.

A segunda é uma pouco mais complicada, mas também não é nada de outro mundo. Ela serve pra adicionar novos Blocos ao Blockchain.

Integridade

Apesar de a versão anterior já funcionar razoavelmente bem, precisamos adicionar alguma garantia de que o Blockchain não tenha sido alterado por algum ataque malicioso.

Precisamos adicionar uma nova função para checar a integridade do Blockchain:

isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}

Lembrando que para verificarmos a integridade do Blockchain precisamos garantir três características:

  • hash de cada Bloco foi gerado corretamente
  • index dos Blocos está em sequência
  • Os Blocos estão ligados entre si através dos hashes

Com essa simples função podemos testar se modificações maliciosas foram feitas e se o Blockchain deve ser invalidado:

const Blockchain = require(./blockchain)
const blockchain = new Blockchain()
blockchain.addBlock({ amount: 4 })
blockchain.addBlock({ amount: 50 })
console.log(blockchain.isValid()) // true
blockchain.blocks[1].data.amount = 30000 // ataque malicioso
console.log(blockchain.isValid()) // false

E finalmente com isso já temos uma primeira versão básica e funcional do Blockchain em JavaScript:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

Problemas

Apesar de já termos uma versão inicial funcionando, ainda podemos melhorar bastante a nossa implementação.

Um dos problemas com essa versão atual é que usuários podem criar novos Blocos de forma muito rápida, podendo invalidar o Blockchain, ou coisas ainda piores. Não vou entrar em muitos detalhes dessa particularidade da tecnologia, mas o post abaixo faz um excelente trabalho nesse sentido:

Explaining blockchain — how proof of work enables trustless consensus

Em resumo, precisamos de alguma ferramenta que não permita que usuários possam criar Blocos desenfreadamente.

Proof of Work

O conceito de Proof of Work, como o próprio nome já sugere, é um mecanismo que faz com que um usuário tenha um trabalho computacional significativo ao realizar determinada tarefa.

Essa ferramenta já era utilizada antes do Bitcoin ser inventado para evitar por exemplo spams e ataques DoS.

No Bitcoin, o Proof of Work funciona da seguinte forma: o hash que é gerado automaticamente em cada Bloco deve começar com uma quantidade X de zeros, dependendo da dificuldade geral do sistema.

Por exemplo, se a dificuldade geral do sistema for 1, esse hash é inválido porque não começa com um zero:

a5036427617139d3ad9bf650d74ae43710e36d4f63829b92b807da37c5d38e8d

Porém, esse outro hash é válido porque começa com um zero:

07da8bff6cfea68a3f0a5bafc9b24d07f503e2282db36ffb58d43f9f4857c54b

Sempre que um usuário for criar um novo Bloco, ele vai precisar criar diversos hashes até que um deles tenha a quantidade de zeros no começo fazendo com que a regra geral do sistema seja atendida.

Ah, o nome disso é Mineração.

Lembrando que quanto maior o número de zeros que devem estar no começo do hash, maior o poder computacional necessário para a tarefa.

Dito isso, vamos agora implementar a versão final do Blockchain com a mineração.

Primeiramente vamos alterar os Blocos.

class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
/* */
}
view rawblock.js hosted with ❤ by GitHub

No construtor, adicionamos os campos difficulty (dificuldade geral do sistema) e nonce (quantidade de tentativas até que o hash correto seja criado). Além disso, temos também um chamada para a função mine.

mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
view rawblock.js hosted with ❤ by GitHub

A função mine vai criar hashes até que a quantidade de zeros à esquerda do hash seja atentida.

Lembrando que para que os hashes criados sejam diferentes, devemos adicionar o campo nonce na função generateHash:

generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
view rawblock.js hosted with ❤ by GitHub

Com isso temos a versão final do Blocos com a mineração:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

Agora basta alterarmos o Blockchain para que o campo difficulty seja passado para os Blocos:

const Block = require(./block)
class Blockchain {
constructor(difficulty = 1) {
this.blocks = [new Block()]
this.index = 1
this.difficulty = difficulty
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const difficulty = this.difficulty
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data, difficulty)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

E é só isso 🙂

Lembrando que o código está todo no GitHub.

Ah, se você quiser saber mais sobre o Blockchain:

Outras implementações:

Fonte: https://tableless.com.br/como-implementar-blockchain-em-javascript/?utm_source=tablelessRelatedLink

Primeiros passos com MongoDB

O MongoDB é um banco de dados documental (Orientado a documentos) open source que proporciona escalabilidade e flexibilidade ao projeto pois ele aninha os dados em documentos JSON e BSON, com isso se tornam simples as buscas. Nesse post farei uma Introdução ao formato “Javascript Object Notation” (JSON), ao BSON e aos primeiros passos com o MongoDB.

O JSON é um formato leve de troca de dados. Para seres humanos, é simples de ler e escrever e para máquinas, é fácil de interpretar e gerar.Quando se fala em aplicações AJAX, o JSON é mais rápido e mais fácil do que o XML.

Com o formato JSON, sempre teremos objetos de Chave-Valor, onde podemos observar alguns pontos característicos:

– As chaves são do tipo “String”.

– O delimitador entre Chave-Valor é o “:” (dois pontos).

– Cada entrada “Chave-Valor” é separada por “,” (vigula).

– Cada objeto JSON é delimitado por “{}” (Chaves).

Utilizando o exemplo abaixo, explicarei os campos que podem compor o “Valor” dentro de um objeto do formato Json.

 

– O nome do livro e a data de lançamento são do tipo “String”.

– A quantidade de páginas é do tipo numérico.

– O status de publicado é do tipo booleano.

– Já o Gênero está recebendo uma matriz.

OBS: Podemos ter valores dos tipos (string, number, object, array, true, false, null)

No mongoDB como complemento ao JSON, existe o BSON que suporta a incorporação de objetos e matrizes dentro de outros objetos e matrizes, ou seja o MongoDB através do BSON cria índices e compara objetos com expressões de consulta em chaves BSON de nível superior que estão aninhadas, isso significa que o MongoDB oferece aos usuários a simplicidade e a flexibilidade dos documentos JSON, juntamente com a velocidade e a riqueza de um formato binário leve.

Basicamente o BSON nasceu com três vértices principais:

– “Lightweight” (Leveza):

O BSON mantem a sobrecarga no mínimo e isso é importante para qualquer formato de representação de dados, especialmente quando usado na rede.

– “Traversable” (Atravessáveis):

O BSON é projetado para mover-se facilmente. Esta é uma propriedade vital para o MongoDB.

– “Efficient” (Eficiente) :

A Codificação de dados e decodificação do BSON pode ser realizada muito rapidamente na maioria das linguagens devido ao uso de tipos de dados C.

Para maiores informações sobre o BSON, segue o link do bsonspec http://bsonspec.org/

Após esta rápida introdução, vamos instalar e dar os primeiros passos com o MongoDB, nesse exemplo vou fazer a instalação em um CentOS, caso você precise instalar em outra plataforma, deixo o link oficial.

– Instalação no Linux.

– Instalação no Windows.

– Instalação no OS X.

Primeiramente vamos adicionar o repositório do MongoDB.

vim /etc/yum.repos.d/mongodb-org.repo

[mongodb-org-3.4]

name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc

 

Vamos atualizar nossa lista de repositórios.

yum repolist

Instalando o MongoDB.

yum install mongodborg

Habilitando o MongoDB em todo boot.

systemctl enable mongod

Iniciando o serviço do MongoDB.

systemctl restart mongod

Nesse momento já podemos acessar a CLI do MongoDB, utilizando o comando “mongo”.

mongo
MongoDB shell version v3.4.3
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 3.4.3
>

Quando acessamos a CLI, nos é mostrado a versão do shell, a string de conexão (mongodb://127.0.0.1:27017) nesse caso localhost e a versão do MongoDB instalado.

OBS: Para limpar a tela, podemos utilizar o “CTRL+L ou cls”

Para termos acesso a uma lista completa de comandos, podemos utilizar o help

 

> help

Vamos listar todos os bancos de dados existentes.

> show dbs
admin 0.000GB
local 0.000GB

 

Por padrão o mongoDB vem com duas bases criadas (local e admin), ambas vazias.

Como o MongoDB é um banco de dados documental, ele não trabalha com tabelas e sim “Collections”, para criarmos as nossas collections precisamos estar dentro de algum banco de dados, para acessamos um banco de dados utilizaremos o comando “use”.

> use livros

 

Percebam que o banco de dados “livros” não existia, quando usamos o comando “use” ele verificou a existência, nesse caso como não existia ele criou automaticamente. Para realizarmos operações de inserção, atualização, leitura e remoção de dados no MongoDB, podemos usar algum script remoto fazendo isso ou podemos executar isso direto no shell. Se executarmos direto no shell, podemos usar uma variável global chamada “db”, essa variável faz referencia ao banco de dados no qual você está conectado, no nosso caso o banco “livros”.

Com esse comando nós vamos fazer uma inserção única em uma collection que ainda não existe.

 

> db.misterios.insertOne({ nome : Ponto de Impacto})
{
acknowledged : true,
insertedId : ObjectId(58ee79afcc3801bb06082423)
}

 

Esse retorno indica duas coisas:

1. A gravação foi reconhecida;

2. Foi gerado um campo único e ele foi atribuído ao documento (todo documento precisa de um _id).

Após isso, a collection “misterios” acabou de ser criada, e possui um documento, para verificar o conteúdo dela, vamos gerar uma listagem completa.

 

1
2
3
> db.misterios.find()
{ “_id” : ObjectId(“58ee79afcc3801bb06082423”), “nome” : “Ponto de Impacto” }

 

Um ponto interessante é que mesmo não passando, o próprio mongo inseriu o campo “_id”, parece ser algo totalmente aleatório, porem segue uma sequencia lógica, é uma string com 12 bytes hexadecimais, como descrito abaixo.

      Data             Mac Address              Pid                 Contador

ObjectId:         _ _ _ _       |           _ _ _            |           _ _         |            _ _ _

Os quatro primeiros campos são criados a partir do segundo atual da máquina, em seguida 3 campos nascem com base no endereço Mac da máquina, depois dois campos surgem do “Process ID” e por último um contador randômico que gera mais 3 bytes.

Farei uma sequencia de posts relacionados a MongoDB, nos posts seguintes, mostrarei outros métodos de inserção e faremos o CRUD utilizando a shell do MongoDB. Espero que esse primeiro post esclareça alguns conceitos do MongoDB e de como ele funciona.

 

 

 

 

Fonte: https://www.fordevops.com/primeiros-passos-com-mongodb/

 

 

Forçando o faker a falar nossa língua

Sem sombra de dúvidas Model Factory é uma das minhas funcionalidades favoritas do Laravel. Lançada a partir da versão do Laravel 5.1, veio para agilizar e facilitar em muito a vida dos desenvolvedores, quanto a necessidade de popular o banco de dados de um projeto com dados falsos.

Mas como nem tudo são flores, existe um inconveniente nesta funcionalidade. Por padrão os dados são gerados na língua inglesa (en_US). Mas o que alguns desenvolvedores não sabem, é que a biblioteca Faker, que é utilizada para criação dos dados falsos, possui suporte a vários idiomas incluindo o nosso (pt_BR).

Sabendo disto, fui atrás de soluções para este inconveniente e em minhas pesquisas encontrei diversas formas de resolver este pequeno problema, abaixo irei listar as formas possíveis que encontrei para solucioná-los.

UTILIZANDO O SERVICE PROVIDER (AppServiceProvider.php)

Supondo que você está trabalhando com uma versão do Laravel igual ou superior à 5.1, basta dizermos ao Laravel que o objeto Faker que será utilizado é o customizado por você. E nesta customização iremos informar que o Locale utilizado será o do nosso idioma (pt_BR).

 

 

<?php
  namespace App\Providers;
  use Illuminate\Support\ServiceProvider;
  use Faker\Generator as FakerGenerator;
  use Faker\Factory as FakerFactory;
  class AppServiceProvider extends ServiceProvider
{
           /**
            * Bootstrap any application services.
            *
            * @return void
           */
            public function boot()
           {
          //
          }
         /**
         * Register any application services.
         *
         * @return void
         */
          public function register()
          {
             $this->app->singleton(FakerGenerator::class, function () {
                 return FakerFactory::create(‘pt_BR’);
                });
         }
}

 

 

Da forma apresentada, toda e qualquer modelfactory criada, automaticamente irá utilizar o nosso objeto faker customizado.

CRIANDO SEU PRÓPRIO OBJETO FAKER (ModelFactory.php)

Outra forma que encontrei, foi a de criarmos uma instância do objeto fakerpara cada modelfactory criada, sempre customizando o objeto, setando olocale para o nosso idioma (pt_BR).

 

<?php
$faker = \Faker\Factory::create(pt_BR);
$factory->define(App\User::class, function () use ($faker) {
return [
name => $faker->name,
email => $faker->freeEmail,
street => $faker->streetAddress,
city => $faker->city,
state => $faker->stateAbbr,
postal => $faker->postcode,
birth_date => $faker->date($format = Y-m-d, $max = now),
password => bcrypt(str_random(10)),
remember_token => str_random(10),
];
});

 

Da forma que acabamos de ver, sempre teremos que instanciar e customizar um objeto faker antes de definirmos uma factory.

ADICIONANDO PROVIDERS AO OBJETO FAKER ORIGINAL (ModelFactory.php)

Outra forma que a biblioteca nos fornece para solucionar este incomodo, é adicionarmos providers no idioma desejado. No nosso caso usaremos os providers em português do Brasil (pt_BR).

 

 

<?php
$factory->define(App\User::class, function (Faker\Generator $faker) {
$faker->addProvider(new Faker\Provider\pt_BR\Address($faker));
$faker->addProvider(new Faker\Provider\pt_BR\Company($faker));
$faker->addProvider(new Faker\Provider\pt_BR\Internet($faker));
$faker->addProvider(new Faker\Provider\pt_BR\Payment($faker));
$faker->addProvider(new Faker\Provider\pt_BR\Person($faker));
$faker->addProvider(new Faker\Provider\pt_BR\PhoneNumber($faker));
return [
name => $faker->name,
email => $faker->freeEmail,
street => $faker->streetAddress,
city => $faker->city,
state => $faker->stateAbbr,
postal => $faker->postcode,
birth_date => $faker->date($format = Y-m-d, $max = now),
password => bcrypt(str_random(10)),
remember_token => str_random(10),
];
});

 

Esta forma nos oferece uma flexibilidade muito grande, pois poderemos customizar/definir o objeto faker apenas com os providers que necessitarmos.

FORMATTERS e PROVIDERS

Cada uma das propriedades do gerador (nameaddressstateloremphoneNumber entre outros) são chamados “formatters”. Um gerador de faker tem diversos formatters, empacotados em “providers”. Aqui está uma lista dos formatadores empacotados no locale padrão.

A classe Faker\Generator por si só não pode fazer muito. Ela precisa de objetos Faker\Provider para delegar a geração de dados. O Faker\Factory::create() na verdade cria um Faker\Generator c0m os providers padrão já embutidos. Logo abaixo podemos ver o que acontece nos bastidores:

<?php
$faker = new Faker\Generator();
$faker->addProvider(new Faker\Provider\en_US\Person($faker));
$faker->addProvider(new Faker\Provider\en_US\Address($faker));
$faker->addProvider(new Faker\Provider\en_US\PhoneNumber($faker));
$faker->addProvider(new Faker\Provider\en_US\Company($faker));
$faker->addProvider(new Faker\Provider\Lorem($faker));
$faker->addProvider(new Faker\Provider\Internet($faker));

 

POPULANDO O BANCO DE DADOS

Depois de solucionado o inconveniente da geração dos dados em nosso idioma ou qualquer outro que desejarmos, chegamos ao ponto crucial, como vamos agora popular o nosso banco de dados?

Simples, iremos utilizar outra funcionalidade do Laravel fantástica, que são os seeders. E para criar um seeder, vamos fazer uso do nosso grande amigo artisan, nosso companheiro de console que está sempre disponível para nos auxilar com rotinas do dia a dia, como criação de (modelsmigrationscontrollersseeders e etc).

Para criarmos nosso seeder, vamos precisar executar o seguinte comando:

$ php artisan make:seeder UsersTableSeeder

E dentro do arquivo que será criado no caminho (Database/Seeds/UsersTableSeeder.php) iremos chamar nossa factory já definida em ModelFactory, especificando que desejamos criar “50” usuários, conforme demostrado abaixo:

 

<?php
use Illuminate\Database\Seeder;
class UsersTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(App\User::class, 50)->create();
}
}

Mas isto já é suficiente para conseguirmos popular o nosso banco de dados?

Precisamos ir em (Database/Seeds/DatabaseSeeder.php) e dizermos para o método run(), método este responsável para executar nossos seeders, quais seeders ele deverá executar. Por padrão o UsersTableSeeder, já vem incluso no DatabaseSeeder, porém encontra-se comentado. Então basta retirarmos o comentário da linha $this->call(UsersTableSeeder::class).

Ficaríamos com o seguinte DatabaseSeeder

 

<?php
use Illuminate\Database\Seeder;
class DatabaseSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$this->call(UsersTableSeeder::class);
}
}

 

 

Agora sim podemos popular nosso banco de dados. Partindo de um princípio de que não tenhamos executado nenhuma migration, e nosso banco de dados já encontra-se devidamente configurado no arquivo .env. Basta agora executarmos o seguinte comando:

$ php artisan migrate –seed

Se tudo ocorreu bem, já teremos em nosso banco de dados os dados gerados pelo Faker neste momento.

O Artisan provê diversas funcionalidades para nós. Para termos uma visão mais ampla do que o artisan pode fazer por nós, basta digitarmos no nosso console o seguinte comando:

$ php artisan

Espero poder contribuir mais a cada dia, e gostaria de deixar claro que o exemplo utilizado neste artigo é apenas ilustrativo, não levei em consideração (boas práticas, normalização entre outras questões) que devem ser levadas em consideração no desenvolvimento de um projeto.

AGRADECIMENTOS

Como esta é minha primeira postagem no Medium, gostaria de agradecer a todos que distribuem conhecimento para a comunidade Laravel Brasil, seja ela de forma gratuita e/ou paga, pois são essas pessoas que ajudam a comunidade a crescer. Peço antecipadamente desculpas caso esqueça de mencionar o nome de algum de vocês, a memória é curta e falha as vezes. Mas quero agradecer aos colegas desenvolvedores: Diego HernandesVinicius ReisFábio VedovelliDaniel LemesLeandro Henrique entre tantos outros nomes.

FONTES DE PESQUISA

 

Fonte: https://medium.com/@vs0uz4/for%C3%A7ando-o-faker-a-falar-nossa-l%C3%ADngua-72d9ee73244c

 

 

 

 

Instalação e configuração do MongoDB como serviço do Windows

Olá pessoal. Gostaria de ilustrar através desse tutorial como instalar e configurar o MongoDB como um serviço do Windows.

O MongoDB é um banco de dados NoSQL (Not Only SQL), ou seja, os dados são armazenados em coleções de documentos organizados no formato JSON (Java Script Object Notation); bancos de dados convencionais utilizam tabelas com conjuntos fixos de colunas.

Uma das principais vantagens é a possibilidade de flexibilizar a estrutura do documento. O MongoDB utiliza o conceito Free Schema Design e um documento é independente do outro, mesmo estando na mesma coleção.

Para começar os trabalhos utilizando o MongoDB no Windows, é necessário fazer o download do arquivo .msi no site: https://www.mongodb.com/download-center#community

Após realizar o download, execute o arquivo e instale o MongoDB. Durante o processo de instalação, selecione no wizard a opção customizada. Dessa forma será possível alterar o diretório de instalação dos arquivos.

Em seguida, clique no botão Install, conceda permissões de administrador e aguarde para que o MongoDB seja instalado no diretório selecionado. O MongoDB será instalado no diretório informado e sua estrutura deverá ser parecida com a imagem abaixo:

A pasta bin contém os arquivos executáveis, que são necessários, para configurar o MongoDB como um serviço do Windows. Especificamente o arquivo mongod.exe. Esse arquivo é utilizado para indicar ao MongoDB o caminho dos arquivos com as coleções de dados e logs de atividades.

Para essa tarefa, acesse o diretório onde o MongoDB foi instalado no Windows e crie duas pastas, uma com o nome data e outra como log. A pasta data armazenará os arquivos com as coleções de dados. A pasta log armazenará os arquivos com os registros de atividades realizadas no MongoDB.

Após criar as pastas data e log, acesse o console do sistema operacional e navegue até a pasta bin dentro do diretório de instalação do MongoDB e execute o seguinte comando:

No comando acima, o parâmetro install informa ao sistema operacional que o MongoDB deverá ser configurado como um serviço. O parâmetro dbpath informa qual pasta deverá armazenar as coleções de dados e o parâmetro logpath informa o endereço do arquivo de log de atividades do banco de dados.

Após a execução com sucesso, acesse a guia de serviços do Windows e verifique que um novo serviço chamado MongoDB foi configurado. Em seguida, clique com o botão direito do mouse sobre o serviço e selecione a opção start.

 

O MongoDB está instalado e configurado como um serviço automatizado do Windows. Para verificar as instâncias de banco de dados criadas é necessário acessar o diretório bin via console e digitar o seguinte comando:

Fontehttp://wikiti.com.br/pt/2017/06/19/instalacao-e-configuracao-do-mongodb-como-servico-do-windows/

 

Banco de dados NoSQL: Um novo paradigma – Revista SQL Magazine 102

Este artigo tem o objetivo de explicar as principais características dos bancos de dados NoSQL.

De que se trata o artigoEste artigo tem o objetivo de explicar as principais características dos bancos de dados NoSQL. Bancos noSQL se referem a uma classe definida de banco de dados não-relacionais que rompem com uma longa história de banco de dados focados nas propriedades ACID. Para tornar ainda mais clara a diferença trazida por este novo paradigma, este artigo também realiza algumas análises comparativas entre bancos noSQL e relacionais.

Em que situação o tema útil

Conhecer o novo paradigma que vem surgindo na área de banco de dados, noSQL, pode ser considerado muito importante para aqueles que trabalham com banco de dados ou tomadores de decisão da área de tecnologia das organizações. É sempre importante estar atento a novas tecnologias e como elas resolvem problemas provenientes das limitações das tecnologias existentes.

Resumo DevMan

Através deste artigo temos a pretensão de apresentar de forma concisa os fundamentos, características e diferenciais dos bancos de dados NoSQL. Além disso, a autora deste artigo acredita ser de suma importância apresentar os fundamentos relacionados ao Banco de Dados Relacional, assim como realizar diversas comparações entre os dois modelos, para que haja uma melhor compreensão e abstração deste novo paradigma chamado Banco de Dados NoSQL.

A forma como nos comunicamos, trocamos informações e criamos conteúdo mudou muito ao longo dos anos. Estamos vivenciando uma época onde as aplicações Web têm revolucionado o mundo em diversos sentidos e a tendência é que este crescimento habilite a criação de uma série de novas aplicações. O grande volume de dados gerados por estas aplicações Web, aliado com a nova forma de interação com o usuário (dinâmica, eficiente e intuitiva), a escalabilidade sob demanda e a necessidade de um alto grau de disponibilidade, tem fomentado o aparecimento de novos paradigmas e tecnologias.

Todos nós sabemos que o banco de dados relacional tem sido usado há muito tempo em larga escala pelo mundo afora, e desde sua criação, por volta do início dos anos 1970, esse tem sido o tipo de banco de dados mais utilizado em empresas que possuem um intenso volume de dados para serem armazenados [1]. Pensando justamente neste imenso volume de dados que tende a crescer a cada momento, começa a se observar que os bancos de dados relacionais possuem certos fatores limitantes, principalmente quando nos referimos a escalabilidade de um sistema [3]. Este ambiente envolto de limitações que os bancos de dados relacionais têm propiciado instigou o surgimento de outros tipos de modelos alternativos de banco de dados que possam suprir essa necessidade.

Diante de tantas dificuldades que são encontradas à medida que as necessidades surgem, está crescendo uma nova geração de banco de dados que vem ganhando bastante força e espaço, estes são conhecidos como NoSQL (“Not Only SQL”) [4], este é o termo genérico que define um banco de dados não-relacional. Este modelo veio com a proposta de atender e gerenciar os grandes volumes de dados, buscando um alto desempenho e disponibilidade. Neste contexto, neste artigo serão apresentadas características desses bancos de dados e se discute ainda como essas novas soluções podem abordar questões que estão sendo atualmente enfrentadas.

História e característica do banco de dados relacional

O banco de dados relacional surgiu como um sucessor dos modelos hierárquicos de rede. Estas estruturas, por sua vez, foram muito utilizadas nos primeiros sistemas de mainframe. No entanto, devido ao grande número de restrições de relacionar estruturas no mundo real, este modelo foi perdendo força para dar lugar aos bancos de dados relacionais [5]. Este, por último, se tornou o grande padrão para a maioria dos Sistemas Gerenciadores de Banco de Dados (SGBDs). Outro ponto importante a salientar sobre o modelo relacional é a utilização de restrições de integridade que garantem a consistência dos dados em um banco de dados. Estas restrições, em sua grande maioria, são conhecidas como chaves primárias (PRIMARY KEY) e chaves estrangeiras (FOREIGN KEY).

Outra característica que devemos ressaltar no Modelo Relacional é o que chamamos de processo de Normalização. Seu objetivo é a aplicação de uma série de passos com determinadas regras sobre a tabela do banco de dados de forma a garantir o projeto adequado dessas tabelas. Um conceito básico da normalização consiste na separação de dados referentes a elementos distintos em tabelas distintas, associadas através da utilização das chaves. Essas regras permitem um armazenamento consistente e, além disso, um eficiente acesso aos dados, reduzindo redundâncias e diminuindo as chances dos dados se tornarem inconsistentes [7].

Além disso, o modelo relacional começou a adotar uma linguagem para a manipulação e consulta destes dados. Estamos nos referindo ao SQL (Structured Query Language). Criada originalmente pela IBM e inspirada na álgebra relacional, ganhou grande destaque pela facilidade do seu uso, diferenciando-a assim de todas as outras linguagens procedurais da época. Devido a sua grande utilização em 1982, o American National Standard Institute (ANSI) tornou o SQL o padrão oficial de linguagem em ambiente relacional, consolidando assim a sua posição de dominância no modelo relacional [1].

Não é possível falar de SQL sem falar também do SGBD, que se caracteriza como um conjunto de programas que permitem armazenar, modificar e extrair em um banco de dado. Falando mais atentamente sobre o assunto, podemos afirmar que o SGBD oferece aos seus usuários processos de validação, recuperação de falhas, segurança, otimização de consultas, garantia de integridade dos dados, entre outros [8].

Além disso, os SGBDs Relacionais oferecem a possibilidade de vários usuários acessarem e manipularem um mesmo banco de dados simultaneamente e principalmente de forma eficiente, algo que é fundamental em sistemas de grande porte.

Os SGBDs relacionais ainda possuem a possibilidade do sistema se recuperar adequadamente de possíveis falhas, ou seja, ele tem a capacidade de voltar ao ponto anterior em que ocorreu a falha, permitindo assim um banco de dados mais consistente.

Vale ressaltar ainda que os bancos de dados relacionais seguem o modelo ACID para preservar a integridade de uma transação. Este conjunto de procedimentos é dividido em quatro propriedades, e são elas:

• Atomicidade: As ações que compõe a ação da transação devem ser concluídas com sucesso para ser efetivada. Se esta transação falhar, será feito o rollback.

• Consistência: Todas as regras/restrições descritas no banco de dados devem ser obedecidas garantindo que o banco de dados passe de uma forma consistente para outra forma consistente.

• Isolamento: Neste caso, a propriedade de isolamento garante que a transição não será interferida por nenhuma outra transação concorrente.

• Durabilidade: Os resultados de uma transação são permanentes, ou seja, o que foi salvo não será mais perdido.

Todos esses diferentes recursos auxiliaram a manter os SGBDs Relacionais sempre em uma posição de predominância entre os mais diversos tipos de ambientes computacionais, mas ao mesmo tempo, não impediu o aparecimento de determinados problemas, isso devido ao grande crescimento do volume de dados presente nos bancos de dados de algumas organizações.

Limitações dos bancos de dados relacionais

Nos dias de hoje, o volume de dados de certas organizações, como podemos citar o caso do Facebook, que atingiu o nível de petabytes (em 2011 este volume de dados ultrapassou 30 petabytes (30 mil terabytes), sendo que menos de um ano antes o volume era de 20 petabytes). Este é um exemplo real de como esse crescimento de dados tem expandido rapidamente [11]. No caso destes tipos de organizações, a utilização dos SGBDs relacionais tem se mostrado muito problemática e não tão eficiente.

Os principais problemas encontrados com a utilização do Modelo Relacional estão principalmente na dificuldade de conciliar o tipo de modelo com a demanda da escalabilidade que está cada vez mais frequente.

Podemos tomar como exemplo o próprio Facebook. Digamos que se o sistema está rodando sobre um SGBD relacional e houver um crescimento do número de usuários, consequentemente haverá uma queda de performance. E para superar este problema seria necessário fazer um upgrade no servidor ou aumentar o número de servidores.

Se o número de usuários continuasse a crescer intensamente, tais soluções apresentadas não se mostrariam suficientes, pois o problema passa a se concentrar no acesso à base de dados. Neste caso, o que poderia ser feito para resolver este problema de escalabilidade seria aumentar o poder do servidor, aumentando sua memória, processador e armazenamento. Este tipo de solução é chamado de Escalabilidade Vertical. Por outro lado, poderíamos aumentar o número de máquinas no servidor web, chamamos esta alternativa de Escalabilidade Horizontal [13].

Vamos citar novamente o Facebook, onde suas aplicações continuam sempre a crescer, chega um momento em que o banco de dados não consegue atender todas as requisições em um tempo hábil. Neste momento poderíamos apelar para a Escalabilidade Vertical e fazer o upgrade na máquina em que está rodando o banco de dados. No entanto, chega um momento em que a capacidade da máquina chega ao limite do orçamento para conseguir uma máquina realmente eficiente. Dessa forma, o próximo passo seria utilizar a Escalabilidade Horizontal, ou seja, colocar mais máquinas rodando o banco de dados. Tal tarefa pode parecer simples, porém, no momento em que escalonamos o banco em diversas máquinas é necessário realizar na grande maioria das vezes uma série de configurações e alterações nas aplicações para que tudo funcione como esperado na nova arquitetura distribuída.

Ainda no campo dos exemplos, vamos imaginar um sistema fictício, e que não se sabe ao certo os campos de determinada entidade, agora imagine este mesmo sistema do dia para a noite sendo acessado por milhares e milhares de pessoas. No outro dia, ao observar sua caixa de email você percebe que diversos usuários possuem ideias realmente inovadoras, porém, para implementar essas ideias no seu sistema é necessário que o banco de dados praticamente por inteiro seja refatorado, afinal, será necessário realizar diversas mudanças estruturais na base de dados . Com este problema em mãos podemos perceber que o Modelo Relacional está focado nos relacionamentos entre as entidades e que isso, por muitas vezes, torna mais “burocrática” a implementação de novas funcionalidades, além dos problemas voltados para a escalabilidade que já havíamos falado, quando há um acesso muito grande de usuários ao sistema.

Como esse intenso volume de dados vem aumentando e pela sua natureza estrutural, os desenvolvedores perceberam a dificuldade ao se organizar dados no Modelo Relacional. É neste ponto que o foco das soluções não-relacionadas está direcionado.

Um novo paradigma: Banco de Dados NoSQL

Pensando em solucionar diversos problemas relacionados à escalabilidade, performance e disponibilidade, projetistas do NoSQL promoveram uma alternativa de alto armazenamento com velocidade e grande disponibilidade, procurando se livrar de certas regras e estruturas que norteiam o Modelo Relacional. Se por um lado havia um rompimento das regras do Modelo Relacional, por outro lado havia ganho de performance, flexibilizando os sistemas de banco de dados para as diversas características que são peculiares de cada empresa. Esta flexibilidade passou a se tornar fundamental para suprir os requisitos de alta escalabilidade necessários para gerenciar grandes quantidades de dados, assim como para garantir uma alta disponibilidade destes, característica fundamental para as aplicações Web 2.0. Algumas grandes organizações passaram a investir em seus próprios SGBDs baseando-se na ideia do NoSQL.

O termo NoSQL foi inicialmente utilizado em 1998 a partir de uma solução que não oferecia uma interface SQL, mas este sistema tinha como base o Modelo Relacional. Futuramente, o modelo passou a representar determinadas soluções que se tornavam melhores que a utilização do Modelo Relacional, desde então passou a utilizar a abreviação Not Only SQL (Não apenas SQL) [13]. A proposta dos bancos NoSQL na realidade não é extinguir o Modelo Relacional, mas utilizá-lo em casos onde é necessária uma maior flexibilidade na estruturação do banco.

Este movimento está bastante enraizado no open source. E apesar de existirem muitos bancos de dados nesta categoria, o movimento passou a ganhar mais força quando determinadas empresas consideradas gigantes da tecnologia passaram a utilizar suas próprias implementações proprietárias [14]. Neste caso, podemos citar o Google, que desde 2004 investe no BigTable que foi desenvolvido para suprir as necessidades de armazenamento da empresa, baseado na filosofia do alto desempenho, escalabilidade e disponibilidade [15]. Além disso, temos também o famoso Cassandra, desenvolvido pelo Facebook para lidar com o grande fluxo de informações [16]. Em 2010 o Cassandra mostrou ser um banco de dados consolidado e passou a ser utilizado pelo Twitter, que utilizava o MySQL anteriormente [17].

Temos ainda o Apache CouchDB, que é um banco de dados open source orientado a documentos que projetado especialmente para suportar computação distribuída em larga escala [18].

Apesar da nomenclatura de todos esses bancos de dados serem NoSQL, eles não são completamente iguais, possuem na verdade muitas características semelhantes e muitas particularidades que os diferenciam.

Principais características dos Bancos de Dados NoSQL

Os bancos de dados NoSQL apresentam determinadas características que considero importantes de serem consideradas neste artigo, além disso, são essas características que os tornam tão diferentes dos bancos de dados relacionais. Algumas dessas características são:

• Escalabilidade Horizontal: na medida em que o volume de dados cresce, aumenta-se a necessidade de escalabilidade e melhoria do desempenho. Dentre todas as possibilidades para esta solução, a escalabilidade horizontal se torna a mais viável, porém requer diversas threads ou que processos de um tarefa sejam criadas e distribuídas. Dessa forma, o uso de um banco de dados relacional poderia ser muito complexo. Não queremos dizer que os bancos de dados relacionais não escalam, a verdade é que eles não escalam facilmente. Isto por que no momento em que diversos processos se conectam simultaneamente em um mesmo conjunto de dados há uma geração de uma alta concorrência aumentando assim o tempo de acesso às tabelas. Neste contexto, uma grande vantagem dos bancos NoSQL é justamente a ausência de bloqueios, o que permite a escalabilidade horizontal com uma maior facilidade e eficiência (ele não é afetado pelo aumento da concorrência). Uma alternativa muito utilizada para alcançar a escalabilidade horizontal é o Sharding, que divide os dados em múltiplas tabelas a serem armazenadas ao longo de diversos nós na rede. O que esta técnica faz, na realidade, é romper a cadeia de relacionamentos, que é uma forte característica nos bancos relacionais. É possível realizar o Sharding em banco de dados relacionais de forma manual. Entretanto, esta não é uma tarefa simples e demonstra complexidade de implementação para a equipe que está desenvolvendo [12].

• Ausência de esquema (Schema-free) ou esquema flexível: Outra característica notável em bancos de dados NoSQL é a ausência parcial ou total de esquema que define a estrutura de dados. É justamente essa ausência de esquema que facilita uma alta escalabilidade e alta disponibilidade, mas em contrapartida não há a garantia de integridade dos dados, fato este que não ocorre no Modelo Relacional [20].

• Suporte nativo a replicaçãoEsta é outra forma de prover a escalabilidade, pois, no momento em que permitimos a replicação de forma nativa o tempo gasto para recuperar informações é reduzido [21].

• API simples para acessar o banco de dados: Em banco de dados NoSQL, o foco não está no armazenamento dos dados e sim como recuperar estes dados de forma eficiente. Pensando nisso, é fundamental APIs desenvolvidas para facilitar o acesso às devidas informações para que se possa usar o banco de dados de forma rápida e eficiente.

• Consistência eventual: Outra característica particular de bancos NoSQL é que nem sempre a consistência dos dados é mantida. Esta característica tem embasamento no teorema CAP (Consistency, Availability e Partition tolerance) que afirma que em um dado momento só é possível garantir duas destas três propriedades, que seriam Consistência, Disponibilidade e tolerância à partição [32]. No mundo real, normalmente estas duas últimas são privilegiadas. Como consequência disto, as propriedades do ACID não são respeitadas simultaneamente, ao contrário disto, temos outro conjunto de projetos denominado BASE (Basicamente disponível, Estado leve e consistente em momento indeterminado) [21]. Ou seja, é necessário haver um planejamento para que o sistema possa tolerar inconsistências temporárias com o objetivo de priorizar a disponibilidade.

Agora que falamos brevemente sobre as principais características nos bancos de dados NoSQL, é importante ressaltar algumas técnicas utilizadas para a implementação de suas funcionalidades. Entre elas estão:

• Map/reduce: permite a manipulação de enormes volumes de dados ao longo de nós em uma rede [23]. Funciona da seguinte forma: na fase map, os problemas são particionados em pequenos problemas que são distribuídos em outros nós na rede. Quando chegam à fase reduce, esses pequenos problemas são resolvidos em cada nó filho e o resultado é passado para o pai, que sendo ele consequentemente filho, repassaria para o seu, até chegar à raiz do problema.

• Consistent hashing: suporta mecanismos de armazenamento e recuperação, onde a quantidade de sites está em constante mudança [24]. É interessante usar essa técnica, pois ela evita que haja uma grande migração de dados entre estes sites, que podem ser alocados ou desalocados para a distribuição dos dados.

• MVCC (Multiversion concurrency control): Oferece suporte a transações paralelas em banco de dados. Por não fazer uso de locks para controle de concorrência, faz com que transações de escrita e leitura sejam feitas simultaneamente [25].

• Vector clocks: Ordenam eventos que ocorreram em um sistema. Como existe a possibilidade de várias operações estarem acontecendo simultaneamente, o uso de um log de operações informando suas datas se faz importante para informar qual versão de um dado é a mais atual [21].

Modelos de banco de dados NoSQL

Neste caso, temos quatro categorias do NoSQL que as diferenciam entre si:

• Chave-valor (key-value): Este modelo é considerado simples e permite a sua visualização através de uma tabela de hash, no qual há uma chave única e um indicador de determinado dado, podendo ser uma String ou um binário [27]. A Figura 1 apresenta um exemplo que armazena informações com estas características. A chave representa um campo como nome e idade e o valor representam os campos preenchidos com Mara Rúbia e 43, ou seja, a instância para o campo correspondente. Este modelo é caracterizado pela sua facilidade ao ser implementado, permitindo que os dados sejam acessados rapidamente através da chave, aumentando também a disponibilidade do acesso aos dados. Para manipulá-los, utilizamos comandos simples como get() e set(), que retornam e capturam valores. Um problema enfrentado por este tipo de banco de dados é que o mesmo não permite a recuperação de objetos através de consultas mais complexas. Como exemplo, podemos citar o Dynamo que foi desenvolvido pela Amazon como solução de alta disponibilidade para suas necessidades [28].

Figura 1. Campos e informações

• Banco de Dados Orientado a Documento: Como o próprio nome sugere, este modelo armazena coleções e documentos. Explicando melhor, um documento, no geral, é um objeto identificador único e um conjunto de campos que podem ser strings, listas ou documentos aninhados [27]. Diferente do banco de dados chave-valor onde se cria uma única tabela hash, neste modelo temos um agrupamento de documentos sendo que em cada um destes documentos temos um conjunto de campos e o valor deste campo. Neste modelo temos ausência de esquema pré-definido (schema free). Isto significa que é possível que haja atualizações no documento, com a adição de novos campos, por exemplo, sem afetar adversamente outros documentos. Outra característica interessante é que não é necessário armazenar valores de dados vazios para campos que não possuem um valor. Na Figura 2 temos o exemplo de um determinado documento que foi definido por: Assunto, Autor, Data, Tags e Mensagens. Caso eu deseje implementar outro campo chamado “Minha opinião sobre o site:”, não haverá nenhum tipo de restrição ou complexidade de inserir tal dado no banco de dados, esta flexibilidade é um ponto forte neste tipo de modelo. Como exemplo de sistema de banco de dados que utiliza este tipo de solução destacamos o CouchDB e o MongoDB. O CouchDB utiliza o formato JSON e é implementado em Java. Já o mongo é implementado em C++ e permite tanto concorrência quanto replicação.

Figura 2. Documento com informações

• Orientado a Coluna (column family): Demonstra maior complexidade que o de chave-valor. Este tipo de banco de dados foi criado para armazenar e processar uma grande quantidade de dados distribuídos em diversas máquinas. Aqui existem as chaves, mas neste caso, elas apontam para atributos ou colunas múltiplas. Neste caso, os dados são indexados por uma tripla (coluna, linha e timestamp), a coluna e linha são identificadas por chaves e o timestamp permite diferenciar múltiplas versões de um mesmo dado [14]. Como o próprio nome sugere, as colunas são organizadas por família da coluna. Vale destacar que as operações de escrita e leitura são atômicas, ou seja, os valores associados a uma linha são considerados em sua execução, independente das colunas que estão sendo lidas/escritas. O conceito associado a este modelo é o de família de colunas, com o objetivo de reunir colunas que armazenam o mesmo tipo de informação. Como exemplo, a Figura 3 modela o conceito de amigos, onde o primeiroNome e sobrenome são colunas pertencentes à família de colunas denominada “nome”. Da mesma forma, as colunas endereço, cidade e estado pertencem à família local. É interessante observar que na linha 001 a pessoa Mara tem diversos endereços. Como a busca neste tipo de banco de dados é atômica, mesmo que o interesse seja buscar o primeiroNome da linha 001, todas as colunas serão retornadas quando esta mesma linha for consultada. Este modelo permite ainda o particionamento de dados, oferecendo forte consistência, no entanto, a alta disponibilidade é o seu ponto fraco. Este modelo de dados surgiu com o BigTable criado pelo Google [15]. Além do BigTable temos também o Cassandra que foi desenvolvido pelo Facebook [16].

Figura 3. Representação de amigos

• Orientado a Grafos: este modelo possui três componentes básicos: nós (vértices dos grafos), os relacionamentos (arestas) e as propriedades (conhecidos também como atributos). Este modelo é visto como multigrafo rotulado e direcionado, onde cada par de nós pode ser conectado por mais de uma aresta. A utilização deste modelo é muito útil quando é necessário fazer consultas demasiadamente complexas. O modelo orientado a grafos possui uma alta performance, permitindo um bom desempenho nas aplicações [27]. Para exemplificar o que foi dito, podemos analisar a Figura 4 que representa uma aplicação que mantêm informações relativas à viagem. Uma consulta pertinente seria: “Quais cidades foram visitadas anteriormente por pessoas que foram para Nova Iorque?”. No modelo de banco de dados relacional tal consulta poderia se mostrar complexa, pois não permitem que os dados sejam representados de uma forma natural.

Como exemplo, podemos citar o Neo4j que é um banco de dados open source. O Neo4J trata-se de um banco de dados baseado em grafos desenvolvido em Java. Além de possuir suporte completo para transactions, ele também trabalha com nós e relacionamentos. Ainda no exemplo da Figura 4, temos diversas pessoas: João, Ricardo, Carolina, Maria, Fernando e Fábio que representam nós do grafo e estão conectadas a cidades que visitaram ou residiram. Por exemplo: Ricardo viajou para Roma e Bruxelas e já residiu em Toronto e Paris. A partir de cada cidade, precisamos dos relacionamentos de entrada que também sejam do tipo “viajou” e com isso encontramos pessoas que viajaram para o mesmo lugar que Ricardo, neste caso, Carolina e Fernando.

Figura 4.Nós do grafo

Levando em consideração tudo o que foi dito, é fundamental ressaltar que nenhum modelo é superior a outro. Na realidade, o que ocorre é que um modelo pode ser mais adequado para ser utilizado em certas situações. Por exemplo, para a utilização de um banco de dados de manipulação de dados que frequentemente serão escritos, mas não lidos (um contador de hits na Web, por exemplo), pode ser usado um banco de dados orientado a documento como o MongoDB. Já aplicativos que demandam alta disponibilidade, onde a minimização da atividade é essencial, podemos utilizar um modelo orientado a colunas como o Cassandra. Aplicações que exigem um alto desempenho em consultas com muitos agrupamentos podem utilizar um modelo orientado a grafos.

O importante é que no momento da criação do aplicativo os desenvolvedores utilizem a melhor solução que se encaixa no perfil desejado. Utilizar a solução adequada ao criar o banco de dados significa uma diminuição dos custos para a sua criação, assim como um banco eficiente no processamento de dados do ponto de vista das suas necessidades.

Principais diferenças entre SGBDs Relacionais e NoSQL

A partir do momento em que se pensa na possibilidade de utilizar um banco de dados NoSQL ao invés de um modelo relacional, é preciso levar algumas questões em consideração, como critérios de escalonamento, consistência e disponibilidade de dados. Vamos apresentar algumas discussões comparativas mais marcantes no que se diz respeito a estes três conceitos.

Falar sobre escalabilidade é essencial porque é neste aspecto que os bancos de dados NoSQL possuem uma grande vantagem em relação aos SGBDs tradicionais, basicamente por terem sido criados para essa finalidade. Os bancos de dados relacionais possuem uma estruturação que não a permite tanta flexibilidade, além disso, é menos adaptada para situações em que o escalonamento se faz necessário.

Para alcançar uma melhor escalabilidade, os bancos de dados relacionais utilizam o recurso da escalabilidade vertical (scale up) que tem como característica a simplicidade de sua implementação e esta tem sido a forma mais indicada para se realizar o escalonamento do banco de dados. A partir do momento em que uma aplicação está sendo demasiadamente acessada por um número muito grande de usuários, este tipo de escalonamento passa a não ser mais suficiente. O próximo passo consiste em escalonar o próprio banco de dados, que consiste basicamente em distribuir o banco em várias máquinas, particionando os dados. Conhecido também como sharding ou escalonamento horizontal. Esse tipo de escalonamento se mostra muito complexo ao ser implementado em um SGBD relacional devido à dificuldade em se adaptar a toda estrutura lógica do Modelo Relacional, primeiro porque os SGBDs relacionais obedecem aos critérios de normalização e o processo de sharding vai contra a tudo isso, pois se caracteriza pela desnomarlização dos dados. Segundo ponto, há uma mudança de paradigma em relação ao processo de escalonamento. Enquando SGBDs tradicionais trabalham para reforçar o servidor, o sharding tem como objetivo trabalhar com o escalonamento horizontal, distribuindo seus dados em diversos setores. Terceiro ponto, o volume de dados por máquina é minimizado devido a esta distribuição, afinal, conjunto de dados menores são mais simples de serem gerenciados, acessados e atualizados. Por último, a disponibilidade do sistema é otimizada em relação ao modelo relacional, pelo fato de que se houver a queda do sistema em uma máquina não irá causar a interrupção do mesmo.

Esta questão da disponibilidade demonstra muita preocupação em determinadas organizações. Podemos citar um evento que ocorreu em 2008, em que a rede social Twitter ficou fora do ar durante 84 horas, neste evento o Twitter ainda utilizava o PostgreSQL, sendo considerada a rede social mais instável daquele ano [30]. A partir de 2009, quando começou a utilizar o Cassandra, outro evento similar ocorreu, porém o site ficou fora dor ar durante 23 horas e 45 minutos [17].

Neste quesito, o banco de dados NoSQL se destaca pela maior disponibilidade, maior rapidez nas consultas, paralelismo de atualização de dados e maior grau de concorrência.

Os bancos de dados NoSQL foram projetados para este fim, e da forma mais simples e natural possível. Como exemplo podemos citar o MongoDB que inclui um módulo de sharding automático que permite a construção de um cluster de banco de dados escalado horizontalmente para, dessa forma, incorporar novas máquinas de forma dinâmica [19].

Outra coisa que devemos notar ao fazer a comparação de uma banco de dados relacional e NoSQL é no que se refere ao controle de concorrência. Se por um lado, no Modelo Relacional utilizamos locks para garantir que dois usuários não acessem o mesmo item simultaneamente, no banco de dados NoSQL utilizam-se outras estratégias que acabam por permitir um maior grau de concorrência. Para citar uma dessas estratégias podemos citar como exemplo o banco de dados CouchDB que utiliza o MMVC. A ideia principal é criar diversas versões dos documentos e permitir a atualização sobre uma dessas versões mantendo ainda a versão desatualizada. Agindo dessa forma não há a necessidade de bloquear os itens dos dados.

Ao se pensar em substituir um banco de dados relacional por um NoSQL, a arquitetura fica vulnerável à perda de consistência, porém, pode-se ganhar em flexibilidade, disponibilidade e performance. Outra coisa interessante para ser destacada são as diferenças de paradigmas utilizadas no Modelo Relacional e nos bancos NoSQL. No que diz respeito a este primeiro, temos o ACID que força a consistência ao final de cada operação, já o paradigma BASE, que é utilizado comumente pelo segundo, permite que o banco de dados eventualmente seja consistente, ou seja, o sistema só torna-se consistente no seu devido momento.

Para compreendermos melhor todas essas diferenças, observe a Tabela 1 que exemplifica de forma concisa alguns dos conceitos descritos neste artigo.

Banco de Dados Relacional Banco de Dados NoSQL
Escalonamento É importante lembrar que é possível ser feito o escalonamento em um Modelo Relacional, no entanto, é muito complexo. Possui uma natureza estruturada, portanto, a inserção dinâmica e transparente de novos nós a tabela não é realizada naturalmente. Não possui um esquema pré-definido fazendo com que este tipo de modelo seja flexível o que favorece a inserção transparente de outros elementos.
Consistência Neste quesito, o Modelo Relacional se mostra forte. As suas regras de consistência são bastante rigorosas no que diz respeito à consistência das informações. É realizada eventualmente no modelo: tem apenas a garantia que se não houver nenhuma atualização nos dados, todos os acessos aos itens devolverão o último valor que foi atualizado.
Disponibilidade Por não conseguir trabalhar de forma eficiente com a distribuição de dados, o Modelo Relacional acaba não suportando uma demanda muito grande de informações. Outro ponto forte neste modelo é o que diz respeito à disponibilidade, pois possui um alto nível de distribuição de dados, permitindo assim que seja possível fazer com que um enorme fluxo de solicitações aos dados seja atendido com a vantagem do sistema ficar indisponível o menor tempo possível.

Tabela 1. Análise comparativa entre Banco de Dados Relacional e NoSQL

Conclusão

Com o grande crescimento do volume de dados em determinadas organizações, os bancos de dados NoSQL tem se tornado uma grande alternativa quando nos referimos a escalabilidade e disponibilidade, fatores estes que se tornam imprescindíveis em algumas aplicações Web.

Para realizar a migração de um SGBD Relacional para um banco de dados NoSQL é preciso levar diversos fatores em consideração. A empresa em questão deve mensurar as diversas vantagens e desvantagens propostas por ambos os modelos, e estes critérios de comparação são dos mais diversos tipos, indo desde a escalabilidade do sistema, passando por avaliação sobre consistência de dados e quão importante é a disponibilidade do banco de dados para o sistema.

Em relação a bancos de dados relacionais, sabemos da sua “experiência” no mercado, no qual é utilizado em larga escala. Além disso, sabemos da solidez de suas soluções que são mais maduras e experimentadas. Enquanto isso, os bancos de dados NoSQL ainda estão conquistando seu espaço no mercado e definindo os seus próprios padrões. Além disso, sabemos que para diversas organizações a consistência de dados se torna um fator determinante e as transações através dos SGBDs Relacionais são a melhor alternativa para lidar com esse problema.

Por outro lado, temos o problema do grande volume de dados enfrentado por diversas empresas, assim como a necessidade que estes sistemas estejam disponíveis para os seus usuários. Nestas situações, os bancos de dados NoSQL acrescentam diversos pontos positivos, primeiro pela sua possibilidade de escalonamento e pela simplicidade do seu modelo, onde não há esquemas pré-definidos, e segundo pela existência de uma grande distribuição de dados, oferecendo assim um maior suporte de solicitações a estes dados para serem atingidos. Adicionalmente, é importante ressaltar que uma escalabilidade em alto grau se faz necessária a empresas que utilizam um banco de dados de grande porte e onde a disponibilidade é um fator decisivo. Acredito que a utilização de um banco de dados NoSQL onde a escalabilidade e a disponibilidade não se demonstre determinante, ainda é algo que é necessário discutir.

Neste sentido, este artigo teve a finalidade de explicar as principais características dos bancos de dados NoSQL e de forma mais concisa o banco de dados Relacional, assim como realizar algumas análises comparativas entre estes dois modelos que atualmente disputam e complementam o mercado. Ressaltando que não existe um banco de dados superior ao outro, a decisão do uso de cada um se refere à necessidade que a empresa está enfrentando.

Referências1. http://www.jornaltemporeal.com/2010/06/10/o-crescimento-da-internet-o-avanco-da-tecnologia-pelo-mundo/

2. http://nosql-database.org/

3. http://uniredes.org/kb/?View=entry&EntryID=224

4. http://www.ime.usp.br/~andrers/aulas/bd2005-1/aula11.html

5. http://www.dicasparacomputador.com/pesquisa-revela-que-empresas-tem-dificuldade-administrar-grandes-volumes-dados.

6. http://www.infoq.com/br/news/2011/08/facebook-maior-migracao.

7. http://escalabilidade.com/2010/03/08/introducao-ao-nosql-parte-i/.

8. http://blog.caelum.com.br/bancos-de-dados-nao-relacionais-e-o-movimento-nosql/

9. F. Chang , J. Dean , S. Ghemawat , W. C. Hsieh , D. A. Wallach , M. Burrows , T. Chandra , A. Fikes , R. E. Gruber, “Bigtable: A distributed storage system for structured data”, In Proceedings of the 7th Conference on Usenix Symposium on Operating Systems Design And Implementation, Volume 7, 2006.

10. Lakshman, P. Malik, “Cassandra – A Decentralized Structured Storage System”, LADIS 2009.

11. http://computerworld.uol.com.br/tecnologia/2010/02/23/crescimento-faz-twitter-trocar-o mysql-pelo-cassandra/.

12. J. C. Anderson, N. Slater, J. Lehnardt,, “CouchDB: The Definitive Guide”, 1ª edição, O’Reilly Media, 2009.

13. http://www.mongodb.org/.

14. http://www.igvita.com/2010/03/01/schema-free-mysql-vs-nosql/.

15. http://dbpedias.com/wiki/NoSQL:Consistency_Models_in_Non-Relational_Databases.

16. http://ccsl.ime.usp.br/wiki/images/2/20/NoSQL_Vantagens_Desvantagens_e_Compromissos.pdf.

17. http://www.nosqldatabases.com/main/tag/consistent-hashing.

18. http://dbpedias.com/wiki/NoSQL:Consistency_Models_in_Non-Relational_Databases.

19. https://www.ibm.com/developerworks/mydeveloperworks/blogs/fd26864d-cb41-49cf-b719-d89c6b072893/entry/escolhendo_a_ferramenta_certa_para_o_banco_de_dados_nosql1?lang=en.

20. http://www.allthingsdistributed.com/2007/10/amazons_dynamo.html.

21. http://nosqlba.com.br/.

22. http://idgnow.uol.com.br/internet/2009/02/19/twitter-e-o-servico-social-mais-instavel durante-2008-aponta-estudo/.

23. http://www.ffb.edu.br/sites/default/files/tcc-20102-gleidson-sobreira-leite.pdf .

24. W. Vogels, “Eventually Consistent”, Scalable Web Services, Volume 6 No. 6, Outubro de 2008.

Fonte: https://www.devmedia.com.br/banco-de-dados-nosql-um-novo-paradigma-revista-sql-magazine-102/25918

SQL em PL / SQL

Neste tutorial, vamos aprender como usar o SQL em PL / SQL. O SQL é o componente atual que cuida da busca e atualização de dados no banco de dados, ao passo que PL / SQL é o componente que processa esses dados. Além disso, neste artigo, também discutiremos como combinar o SQL no bloco PL / SQL.

 

Neste tutorial, você aprenderá –

Transações DML em PL / SQL

CURSOR Concept em PL / SQL

Atributos do cursor

FOR Loop Cursor statement

BULK COLLECT em PL / SQL

Declarações TCL em PL / SQL

Transação Autônoma

Transações DML em PL / SQL

DML significa Idioma de Manipulação de Dados . Essas declarações são usadas principalmente para realizar a atividade de manipulação. Trata-se basicamente das operações abaixo.

Inserção de dados

Atualização de dados

Eliminação de dados

Projeção de dados / busca

Em PL / SQL, podemos fazer a manipulação de dados somente usando os comandos SQL.

Inserção de dados

Em PL / SQL, podemos inserir os dados em qualquer tabela usando o comando SQL INSERT INTO. Este comando levará o nome da tabela, a coluna da tabela e os valores das colunas como a entrada e insira o valor na tabela base.

O comando INSERT também pode levar os valores diretamente de outra tabela usando a instrução ‘SELECT’ ao invés de dar os valores para cada coluna. Através da instrução “SELECT”, podemos inserir tantas linhas como a tabela base contém.

SQL em PL / SQL

Sintaxe Explicação:

A sintaxe acima mostra o comando INSERT INTO. O nome e os valores da tabela são campos obrigatórios, enquanto os nomes das colunas não são obrigatórios se as instruções do inserto tiverem valores para toda a coluna da tabela.

A palavra-chave ‘VALORES’ é obrigatória se os valores forem dados separadamente, como mostrado acima.

SQL em PL / SQL

Sintaxe Explicação:

A sintaxe acima mostra o comando INSERT INTO que leva os valores diretamente do <table_name2> usando o comando SELECT.

A palavra-chave “VALORES” não deve estar presente neste caso, pois os valores não são fornecidos separadamente.

Atualização de dados

Atualização de dados simplesmente significa uma atualização do valor de qualquer coluna na tabela. Isso pode ser feito usando a instrução ‘UPDATE’. Esta declaração leva o nome da tabela, o nome da coluna e o valor como entrada e atualiza os dados.

SQL em PL / SQL

Sintaxe Explicação:

A sintaxe acima mostra a UPDATE. A palavra-chave ‘SET’ instrui esse mecanismo PL / SQL para atualizar o valor da coluna com o valor fornecido.

A cláusula “WHERE” é opcional. Se esta cláusula não for fornecida, o valor da coluna mencionada em toda a tabela será atualizado.

Eliminação de dados

A eliminação de dados significa excluir um registro completo da tabela do banco de dados. O comando ‘DELETE’ é usado para este propósito.

SQL em PL / SQL

Sintaxe Explicação:

A sintaxe acima mostra o comando DELETE. A palavra-chave ‘FROM’ é opcional e com ou sem a cláusula ‘FROM’ o comando se comporta da mesma forma.

A cláusula “WHERE” é opcional. Se esta cláusula não for fornecida, a tabela inteira será excluída.

Projeção de dados / busca

A projeção / busca de dados significa para recuperar os dados necessários da tabela do banco de dados. Isso pode ser alcançado usando o comando ‘SELECIONAR’ com a cláusula ‘INTO’. O comando ‘SELECT’ vai buscar os valores do banco de dados e cláusula de ‘INTO’ irá atribuir esses valores para a variável local do bloco PL / SQL.

Abaixo estão os pontos que precisam ser considerados na indicação “SELECIONAR”.

A instrução “SELECT” deve retornar apenas um registro enquanto usa a cláusula ‘INTO’, uma vez que uma variável pode conter apenas um valor. Se o ‘SELECT’ instrução retorna mais de um valor de exceção ‘TOO_MANY_ROWS’ será gerado.

A instrução “SELECT” atribuirá o valor à variável na cláusula ‘INTO’, por isso precisa obter pelo menos um registro da tabela para preencher o valor. Se não obteve nenhum registro, então a exceção ‘NO_DATA_FOUND’ é gerada.

O número de colunas e seu tipo de dados na cláusula ‘SELECIONAR’ devem corresponder com o número de variáveis ​​e seus tipos de dados na cláusula ‘INTO’.

Os valores são obtidos e preenchidos na mesma ordem mencionada na declaração.

A cláusula “WHERE” é opcional que permite ter mais restrição nos registros que serão obtidos.

A instrução “SELECT” pode ser usada na condição ‘WHERE’ de outras instruções DML para definir os valores das condições.

A instrução ‘SELECT’ ao usar as instruções ‘INSERT’, ‘UPDATE’, ‘DELETE’ não deve ter a cláusula ‘INTO’, uma vez que não irá preencher nenhuma variável nesses casos.

SQL em PL / SQL

Sintaxe Explicação:

A sintaxe acima mostra o comando SELECT-INTO. A palavra-chave ‘FROM’ é obrigatória que identifica o nome da tabela a partir do qual os dados precisam ser obtidos.

A cláusula “WHERE” é opcional. Se esta cláusula não for fornecida, os dados de toda a tabela serão obtidos.

Exemplo 1 : neste exemplo, vamos ver como executar operações DML em PL / SQL. Vamos inserir os seguintes 4 registros na tabela emp.

EMP_NAME EMP_NO SALÁRIO GERENTE
BBB 1000 25000 AAA
XXX 1001 10000 BBB
AAAA 1002 10000 BBB
ZZZ 1003 7500 BBB

Então, vamos atualizar o salário de ‘XXX’ para 15000, e vamos excluir o registro do funcionário ‘ZZZ’. Finalmente, vamos projetar os detalhes do “XXX” do empregado.

SQL em PL / SQL

SQL em PL / SQL

Explicação do código:

Código linha 2-5 : Declarando a variável.

Código linha 7-14 : Inserindo os registros na tabela emp.

Código linha 15 : Cometer as transações inserir.

Código linha 17-19 : atualizando o salário do empregado ‘XXX’ para 15000

Código linha 20 : Cometer a transação de atualização.

Código linha 22 : Excluindo o registro de ‘ZZZ’

Código linha 23 : Cometer a transação de exclusão.

  • Linha de código 25-27 : Selecionando a gravação de ‘XXX’ e preenchendo na variável l_emp_name, l_emp_no, l_salary, l_manager.

 

Linha de código 28-32 : exibindo o valor de registros obtidos.

CURSOR Concept em PL / SQL

O Oracle cria uma área de memória, conhecida como área de contexto, para processar uma instrução SQL, que contém todas as informações sobre a declaração, por exemplo, número de linhas processadas, etc. O cursor não é senão um ponteiro para essa área de contexto.

O PL / SQL permite ao programador controlar a área de contexto através do cursor. Um cursor contém as linhas retornadas pela instrução SQL. O conjunto de linhas que o cursor mantém é referido como conjunto ativo. Esses cursores também podem ser nomeados para que possam ser encaminhados a partir de outro local do código.

O cursor é de dois tipos.

Cursor implícito

Cursor explícito

Cursor implícito

Sempre que ocorrem operações DML no banco de dados, é criado um cursor implícito que contém as linhas afetadas, naquela operação específica. Esses cursores não podem ser nomeados e, portanto, não podem ser controlados ou encaminhados a partir de outro local do código. Podemos referir-se apenas ao cursor mais recente através dos atributos do cursor.

Cursor explícito

Os programadores podem criar área de contexto nomeada para executar suas operações DML para obter mais controle sobre isso. O cursor explícito deve ser definido na seção de declaração do bloco PL / SQL e é criado para a instrução ‘SELECT’ que precisa ser usada no código.

Abaixo estão as etapas que envolvem o trabalho com cursores explícitos.

Declarando o cursorDeclarar o cursor significa simplesmente criar uma área de contexto nomeada para a instrução ‘SELECIONAR’ que está definida na parte da declaração. O nome dessa área de contexto é o mesmo que o nome do cursor.

Cursor de aberturaAbrir o cursor instruirá o PL / SQL a alocar a memória para este cursor. Ele irá preparar o cursor para buscar os registros.

Obtendo Dados do CursorNeste processo, a instrução ‘SELECT’ é executada e as linhas obtidas são armazenadas na memória alocada. Estes são agora chamados de conjuntos ativos. Obter dados do cursor é uma atividade de nível recorde, o que significa que podemos acessar os dados de maneira recorde por gravação.Cada instrução fetch buscará um conjunto ativo e contém as informações desse registro específico. Esta declaração é a mesma que a instrução “SELECIONAR” que obtém a gravação e atribua à variável na cláusula ‘INTO’, mas não lançará nenhuma exceção.

Fechar o cursorUma vez que todos os registros são buscados, precisamos fechar o cursor para que a memória alocada para essa área de contexto seja lançada.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, a parte de declaração contém a declaração do cursor e a variável de cursor na qual os dados obtidos serão atribuídos.
  • O cursor é criado para a instrução ‘SELECT’ que é dada na declaração do cursor.
  • Na parte de execução, o cursor declarado é aberto, recuperado e fechado.

Atributos do cursor

Tanto o cursor implícito como o cursor explícito possuem certos atributos que podem ser acessados. Esses atributos fornecem mais informações sobre as operações do cursor. Abaixo estão os diferentes atributos do cursor e seu uso.

Atributo do Cursor Descrição
%ENCONTRADO Retorna o resultado booleano ‘VERDADEIRO’ se a operação de busca mais recente forçou uma gravação com sucesso, caso contrário, ela retornará FALSA
%NÃO ENCONTRADO Isso funciona da maneira oposta ao% FOUND retornará ‘TRUE’ se a operação de busca mais recente não puder obter qualquer registro.
%ESTÁ ABERTO Retorna o resultado booleano ‘TRUE’ se o cursor já estiver aberto, caso contrário ele retorna ‘FALSE’
%CONTAGEM DE LINHAS Ele retorna o valor numérico. Ele fornece a contagem real de registros que foram afetados pela atividade DML.

Exemplo 1 : neste exemplo, vamos ver como declarar, abrir, buscar e fechar o cursor explícito.

Vamos projetar todos os funcionários nome da tabela emp usando um cursor. Nós também usaremos o atributo do cursor para definir o loop para buscar toda a gravação a partir do cursor.

SQL em PL / SQL

Explicação do código:

  • Código linha 2 : Declarando o cursor guru99_det para a instrução ‘SELECT emp_name FROM emp’.
  • Código linha 3 : Declaração variável lv_emp_name.
  • Código linha 5 : abrindo o cursor guru99_det.
  • Código linha 6: Configurando a instrução do loop básico para buscar todos os registros na tabela ‘emp’.
  • Código linha 7: Obtém os dados guru99_det e atribua o valor a lv_emp_name.
  • Código linha 9: Usando o atributo do cursor ‘% NOTFOUND’ para descobrir se toda a gravação no cursor é buscada. Se for obtido, ele retornará ‘VERDADEIRO’ e o controle sairá do loop, senão o controle continuará comprando os dados do cursor e imprimindo os dados.
  • Código linha 11: condição EXIT para a instrução loop.
  • Linha de código 12: Imprima o nome do funcionário buscado.
  • Linha de código 14: Usando o atributo de cursor ‘% ROWCOUNT’ para encontrar o número total de registros que foram afetados / recuperados no cursor.
  • Código linha 15: Depois de sair do loop, o cursor é fechado e a memória alocada está livre.

FOR Loop Cursor statement

A indicação “PARA LOOP” pode ser usada para trabalhar com cursores. Podemos dar o nome do cursor em vez do limite de intervalo na instrução FOR loop para que o loop funcione a partir da primeira gravação do cursor para a última gravação do cursor. A variável do cursor, a abertura do cursor, a busca e o fechamento do cursor serão realizadas de forma implícita pelo loop FOR.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, a parte de declaração contém a declaração do cursor.
  • O cursor é criado para a instrução ‘SELECT’ que é dada na declaração do cursor.
  • Na parte de execução, o cursor declarado é configurado no loop FOR e a variável de loop ‘I’ se comportará como variável de cursor neste caso.

Exemplo 1 : neste exemplo, vamos projetar todo o nome do empregado da tabela emp usando um cursor-FOR loop.

SQL em PL / SQL

Explicação do código:

  • Código linha 2 : Declarando o cursor guru99_det para a instrução ‘SELECT emp_name FROM emp’.
  • Linha de código 4 : Construindo o loop ‘FOR’ para o cursor com a variável de loop lv_emp_name.
  • Código linha 5: Imprimir o nome do funcionário em cada iteração do loop.
  • Código linha 8: Sair do loop

Nota: No cursor Cursor-FOR, os atributos do cursor não podem ser usados, pois a abertura, a busca eo fechamento do cursor são feitos de forma implícita pelo loop FOR.

BULK COLLECT em PL / SQL

O Oracle PL / SQL fornece a funcionalidade de buscar os registros em massa em vez de buscar um a um. Este BULK COLLECT pode ser usado na instrução ‘SELECT’ para preencher os registros em massa ou em busca do cursor em massa. Uma vez que BULK COLLECT obtém o registro em BULK, a cláusula INTO deve sempre conter uma variável de tipo de coleção. A principal vantagem de usar BULK COLLECT é aumentar o desempenho, reduzindo a interação entre o banco de dados eo mecanismo PL / SQL.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, BULK COLLECT é usado para coletar os dados da indicação ‘SELECT’ e ‘FETCH’.

Cláusula FORALL

O FORALL permite executar as operações DML em dados a granel. É semelhante ao da declaração FOR loop, exceto no FOR loop coisas acontecem no nível recorde, enquanto que no FORALL não existe um conceito LOOP. Em vez disso, todos os dados presentes no intervalo especificado são processados ​​ao mesmo tempo.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, a operação DML dada será executada para todos os dados que estão presentes entre um intervalo mais baixo e mais alto.

Cláusula de Limite

O conceito de coleta em massa carrega todos os dados na variável de coleta de destino como um volume, ou seja, todos os dados serão preenchidos na variável de coleta em uma única etapa. Mas isso não é aconselhável quando o registro total que precisa ser carregado é muito grande, porque quando o PL / SQL tenta carregar todos os dados, ele consome mais memória de sessão. Por isso, é sempre bom limitar o tamanho desta operação de coleta em massa.

No entanto, esse limite de tamanho pode ser facilmente alcançado através da introdução da condição ROWNUM na instrução ‘SELECT’, enquanto que no caso do cursor isso não é possível.

Para superar este Oracle forneceu uma cláusula ‘LIMIT’ que define o número de registros que precisam ser incluídos no volume.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, a instrução de busca do cursor usa a instrução BULK COLLECT juntamente com a cláusula LIMIT.

BULK COLLECT Atributos

Semelhante aos atributos do cursor BULK COLLECT tem% BULK_ROWCOUNT (n) que retorna o número de linhas afetadas na n ª declaração DML da instrução FORALL, ou seja, dará a contagem de registros afetados na declaração FORALL para cada valor da coleção variável. O termo ‘n’ indica a seqüência de valor na coleção, para a qual a contagem de linhas é necessária.

Exemplo 1 : neste exemplo, vamos projetar todo o nome do empregado da tabela emp usando BULK COLLECT e também aumentaremos o salário de todos os funcionários em 5000 usando o FORALL.

SQL em PL / SQL

Explicação do código:

  • Código linha 2 : Declarando o cursor guru99_det para a instrução ‘SELECT emp_name FROM emp’.
  • Código linha 3 : Declarando lv_emp_name_tbl como tipo de tabela do VARCHAR2 (50)
  • Código linha 4 : Declarando lv_emp_name como lv_emp_name_tbl tipo.
  • Código linha 6: abrindo o cursor.
  • Código linha 7: Preenchendo o cursor usando BULK COLLECT com o tamanho LIMIT como 5000 intl lv_emp_name variável.
  • Código da linha 8-11: Configurando FOR loop para imprimir toda a gravação na coleção lv_emp_name.
  • Código linha 12: Usando FORALL atualizando o salário de todo o empregado em 5000.
  • Linha de código 14: Comprometer a transação.

Declarações TCL em PL / SQL

O TCL significa declarações de controle de transações. Ele irá salvar as transações pendentes ou reverter a transação pendente. Essas declarações desempenham o papel vital porque, a menos que a transação seja salva, as alterações por meio de instruções DML não serão salvas no banco de dados. Abaixo estão as diferentes declarações TCL.

COMMIT Salva toda a transação pendente
ROLLBACK Descarte toda a transação pendente
SAVEPOINT Cria um ponto na transação até que o retorno pode ser feito mais tarde
ROLLBACK TO Descarte toda a transação pendente até o especificado <save point>

A transação será completa nos seguintes cenários.

  • Quando qualquer uma das declarações acima é emitida (exceto SAVEPOINT)
  • Quando as declarações DDL são emitidas. (DML são declarações de confirmação automática)
  • QUANDO as declarações DCL são emitidas. (DCL são declarações de confirmação automática)

Transação Autônoma

Em PL / SQL, todas as modificações feitas em dados serão denominadas como uma transação. Uma transação é considerada completa quando o save / descarte é aplicado a ele. Se não for salvo / descartar, a transação não será considerada como completa e as modificações feitas nos dados não serão tornadas permanentes no servidor.

Independentemente de uma série de modificações feitas durante uma sessão, PL / SQL tratará toda a modificação como uma única transação e salvar / descartar essa transação afeta todas as mudanças pendentes naquela sessão. A Transação Autônoma fornece uma funcionalidade para o desenvolvedor em que permite fazer alterações em uma transação separada e salvar / descartar essa transação específica sem afetar a transação da sessão principal.

  • Essa transação autônoma pode ser especificada no nível do subprograma.
  • Para fazer qualquer subprograma para funcionar em uma transação diferente, a palavra-chave ‘PRAGMA AUTONOMOUS_TRANSATION’ deve ser fornecida na seção declarativa desse bloco.
  • Ele instruirá esse compilador a tratar isso como a transação separada e salvar / descartar dentro deste bloco não refletirá na transação principal.
  • Emitir COMMIT ou ROLLBACK é obrigatório antes de sair desta transação autônoma para a transação principal porque, em qualquer momento, apenas uma transação pode estar ativa.
  • Então, uma vez que fizemos uma transação autônoma, precisamos salvá-la e concluir a transação, então só podemos voltar para a transação principal.

SQL em PL / SQL

Sintaxe Explicação:

  • Na sintaxe acima, o bloco foi feito como uma transação autônoma.

Exemplo 1 : neste exemplo, vamos entender como a transação autônoma está funcionando.

SQL em PL / SQL

SQL em PL / SQL

Explicação do código:

  • Código linha 2 : declarando l_salary como NUMBER.
  • Código linha 3 : declarando procedimento de bloqueio aninhado
  • Código linha 4 : Fazendo o procedimento nested_block como ‘AUTONOMOUS_TRANSACTION’.
  • Código linha 7-9: aumentando o salário para o empregado número 1002 em 15000.
  • Código linha 10: Comprometer a transação.
  • Código linha 13-16: Imprimir os detalhes salariais dos funcionários 1001 e 1002 antes das alterações.
  • Código linha 17-19: aumentando o salário para o empregado número 1001 em 5000.
  • Código linha 20: Chamando o procedimento aninhado_block;
  • Código linha 21: descartar a transação principal.
  • Código linha 22-25: Imprimindo os detalhes do salário dos empregados 1001 e 1002 após as mudanças.
  • O aumento de salário para o empregado número 1001 não é refletido porque a principal transação foi descartada. O aumento de salário para o empregado número 1002 é refletido porque esse bloco foi feito como uma transação separada e salvo no final.
  • Portanto, independentemente da gravação / descarte na transação principal, as alterações na transação autônoma foram salvas sem afetar as principais alterações de transação.

Resumo

Neste tutorial, aprendemos a combinar o SQL em PL / SQL para manipulação de dados, Cursor Concepts, Cursor-FOR loop e Bulk collect usages. Nós também discutimos as declarações da TCL e como salvar / descartar transações separadamente.

Fonte

https://www.guru99.com/sql-pl-sql.html

Transaction Autonomous – O Que, Quando, Onde e Por Que

Do que se trata o artigo:

Neste artigo será apresentada a utilização do pragma autonomous Transaction para escrita de códigos autônomos em rotinas PL/SQL, as quais são executadas e commitadas na base independentemente do resultado da transação master que invocou essa rotina.


Em que situação o tema é útil:

Esta funcionalidade é bastante utilizada para geração de logs de erro de transação, onde a transação master sofre rollback depois de uma falha, mas é possível gerar um log contento os dados da transação que resultaram no erro.

Um subprograma normalmente tem suas operações salvas ou não no banco de dados de acordo com o que acontece com o programa principal onde ele está inserido. Isso quer dizer que, se uma procedure chama uma função e a procedure falha, nem as alterações feitas pela procedure nem as alterações feitas pela função são salvas na base, afinal trata-se da mesma transação, a qual é atômica (indivisível, ou seja, ou ela toda é commitada ou ela toda sofre rollback). No entanto, se a função contiver o pragma autonomous_transaction, ela se comporta como uma segunda transação, que é isolada e independente, e suas alterações na base podem ser salvas ou não independentemente da transação master que a originou.

A diretiva AUTONOMOUS_TRANSACTION altera a forma com que a transação trata a um subprograma. Um pragma na verdade é uma diretiva de compilação e os subprogramas marcados com este pragma são processados em tempo de compilação e não em tempo de execução, e passam informações diretamente ao compilador.

O termo AUTONOMOUS_TRANSACTION se refere à habilidade do PL/SQL temporariamente suspender a transação corrente e iniciar uma nova transação, totalmente independente, que funciona de forma autônoma com relação à transação original.

Imagine a seguinte situação: Para fins de auditoria, criamos uma tabela de log que contém os dados referentes a todas as alterações feitas nos dados de 5 tabelas críticas do banco de dados da empresa, armazenando o IP da máquina que originou a transação, qual tabela sofreu alteração, o que foi feito, etc, e um trigger é responsável por inserir tais dados nessa tabela. Pois bem, vamos supor então que por um motivo ou outro essa transação tenha falhado. Não desejamos que os logs de auditoria também sofram rollback, pois estaremos perdendo dados preciosos de tentativas frustradas de acesso não autorizado.

Neste caso, o trigger deve disparar um subprograma autônomo, cujo sucesso da transação não dependa do resultado da transação principal que o originou.

A utilização em tratativas de logs de auditoria são comuns e não causam nenhum tipo de problema ao banco de dados, uma vez que não está lidando com tabelas de negócio, ou seja, que guardam dados essenciais para o negócio. Por este motivo a transação autônoma é segura, pois a integridade do banco de dados está resguardada.

Digo isso porque já vi muitos códigos resolvendo regras de negócio com transações autônomas, o que pode gerar um problema grande para o banco de dados. Imagine que a alteração de um valor em uma tabela deve causar alterações em outras tabelas. Se a primeira alteração falha, o ideal é que as demais alterações não ocorram… neste caso o procedimento que faria as demais alterações não poderia jamais ser autônomo!

Qualquer subprograma, como procedures, funções ou até mesmo blocos anônimos PL/SQL podem conter este pragma. No entanto, se for utilizado dentro de pacotes, o pragma deve ser declarado para as funções e procedures que fazem parte do pacote, e não para o pacote em si.

Exemplo de Utilização

Como um exemplo de utilização da transação autônoma, vamos assumir que precisamos gravar logs de erro em uma tabela do banco de dados. Precisamos fazer rollback da transação principal porque ela resultaria em um erro, mas não queremos perder o log do que aconteceu nessa transação. A tabela que conterá os logs de erro possui a seguinte estrutura:

CREATE TABLE tb_log_erros(

  codigo integer,

  msg varchar2(2000),

  data date,

  usuario varchar2(50),

  nm_mach varchar2(100),

  prog varchar2(100)

);

O procedimento que deve ser invocado para inserir o log do erro na tabela é:

CREATE OR REPLACE PROCEDURE grava_log_erros(

   log_codigo IN INTEGER,

   log_msg IN VARCHAR2) IS

PRAGMA AUTONOMOUS_TRANSACTION;

CURSOR cur_erro IS

SELECT machine, program

FROM v$session

WHERE audsid = USERENV(‘SESSIONID’);

PT = Parent Transaction;

CT = Child Autonomous Transaction;

rec cur_erro%ROWTYPE;

BEGIN

   —

   OPEN cur_erro;

   FETCH cur_erro INTO rec;

   CLOSE cur_erro;

   —

   INSERT INTO tb_log_erros values (

       log_codigo,

       log_msg,

       SYSDATE,

       USER,

       rec.machine,

       rec.program

   );

   COMMIT;

EXCEPTION

   WHEN OTHERS THEN

       ROLLBAACK;

END;

/

Para testar o código acima, podemos executar o seguinte bloco anônimo PL/SQL:

BEGIN

    INSERT INTO HR.EMPLOYEES (first_name) VALUES (‘Maria’);

    COMMIT;

EXCEPTION

    WHEN OTHERS THEN

         grava_log_erros(SQLCODE,SQLERRM);

    ROLLBACK;

    RAISE;

END;

Ao executar o código acima, basta verificar nas tabelas EMPLOYEES e TB_LOG_ERROS as linhas inseridas, como segue:

SQL> select * from employees where first_name = ‘Maria’;

no rows selected.

SQL> select codigo, msg from tb_log_erros;

CODIGOMSG

——————————————————————————————————–

-1400ORA-01400: cannot insert NULL into (“HR”.”EMPLOYEES”.”EMPLOYEE_ID”)

Referências

BURLESON CONSULTING. PL/SQL Autonomous Transaction Tips. Burleson Consulting, 2015. Disponivel em: http://www.dba-oracle.com/t_autonomous_transaction.htm

ORACLE HELP CENTER. Autonomous_transaction Pragma. Database PL/SQL User’s Guide and Reference, 2017. Disponivel em: https://docs.oracle.com/cd/B19306_01/appdev.102/b14261/autonotransaction_pragma.htm

Sistemas de Banco de Dados 6ª Edição – Elmasri

 

sistemas-de-banco-de-dados-6

Download Sistemas de Banco de Dados 6ª Edição Elmasris

Referência acadêmica tanto teórica como prática, Sistemas de banco de dados apresenta os aspectos mais importantes não apenas dos sistemas, mas também das aplicações de banco de dados, além de diversas tecnologias relacionadas ao assunto.

Atualizada, a obra aborda:
– Conceitos fundamentais para projetar e usar os sistemas de banco de dados.
– Fundamentos de modelagem e de projeto de banco de dados.
– Linguagens e modelos fornecidos pelos sistemas de gerenciamento de banco de dados.
– Técnicas de implementação do sistema de banco de dados, com exemplos práticos.
Indicado para os cursos de ciências da computação, desenvolvimento de sistemas, sistemas de informação e engenharia da computação, este livro é também bibliografia básica para cursos de análise de redes, análise de sistemas e processamento de dados.

Sumário
Parte 1. Introdução aos bancos de dados.
1. Bancos de dados e usuários de banco de dados.
2. Conceitos e arquitetura do sistema de banco de dados.

Parte 2. Modelo de dados relacional e SQL.
3. O modelo de dados relacional e as restrições em bancos de dados relacionais.
4. SQL básica.
5. Mais SQL: Consultas complexas, triggers, views e modificação de esquema.
6. Álgebra e cálculo relacional.

Parte 3. Modelagem conceitual e projeto de banco de dados.
7. Modelagem de dados usando o modelo de Entidade-Relacionamento (ER).
8. O modelo de entidade-relacionamento estendido (EER).
9. Projeto de banco de dados relacional por mapeamento de ER e EER para relacional.
10. Metodologia prática de projeto de banco de dados e uso de diagramas UML.

Parte 4. Objeto, objeto-relacional e XML: conceitos, modelos, linguagens e padrões.
11. Bancos de dados de objeto e objeto-relacional.
12. XML: Extensible Markup Language.

Parte 5. Técnicas de programação de banco de dados.
13. Introdução às técnicas de programação SQL.
14. Programação de banco de dados Web usando PHP.

Parte 6. Teoria e normalização de projeto de banco de dados.
15. Fundamentos de dependências funcionais e normalização para bancos de dados relacionais.
16. Algoritmos de projeto de banco de dados relacional e demais dependências.

Parte 7. Estruturas de arquivo, indexação e hashing.
17. Armazenamento de disco, estruturas de arquivo básicas e hashing.
18. Estruturas de indexação para arquivos.

Parte 8. Processamento de consulta, otimização e ajuste de banco de dados; 19. Algoritmos para processamento e otimização de consulta.
20. Projeto físico e ajuste de banco de dados.

Parte 9. Processamento de transações, controle de concorrência e recuperação; 21. Introdução aos conceitos e teoria de processamento de transações.
22. Técnicas de controle de concorrência.
23. Técnicas de recuperação de banco de dados.

Parte 10. Tópicos adicionais de banco de dados: segurança e distribuição
24.Segurança de banco de dados
25. Bancos de dados distribuídos.

Parte 11. Modelos, sistemas e aplicações de bancos de dados avançados.
26. Modelos de dados avançados para aplicações avançadas.
27. Introdução à recuperação de informações e busca na Web.
28. Conceitos de data mining.
29. Visão geral de data warehousing e OLAP; Apêndices; Bibliografia; Índice remissivo.

Estilo: Curso
Tamanho: 131 mb
Ano de Lançamento: 2011
Idioma: Português – BR
Formato: Rar / Pdf
Hospedagem: Depositfiles / Freakshare / Bitshare

Depositfiles Download
Freakshare Download

Freakshare Bitshare

 

Fonte: http://www.sempredownloadfull.net/sistemas-de-banco-de-dados-6-edico-elmasri.html

Tipos de índice – PostgreSQL

O PostgreSQL disponibiliza vários tipos de índice: B-tree (árvore B), R-tree (árvore R), hash [1] e GiST. Cada tipo de índice utiliza um algoritmo diferente, mais apropriado para tipos diferentes de consulta. Por padrão, o comando CREATE INDEX cria um índice B-tree, adequado para a maioria das situações comuns.

Os índices B-tree podem tratar consultas de igualdade e de faixa, em dados que podem ser classificados em alguma ordem. Em particular, o planejador de comandos do PostgreSQL leva em consideração utilizar um índice B-tree sempre que uma coluna indexada está envolvida em uma comparação utilizando um dos seguintes operadores:

<
<=
=
>=
>

As construções equivalentes a combinações destes operadores, tais como BETWEEN e IN, também podem ser implementadas com procura de índice B-tree (Mas deve ser observado que IS NULL não é equivalente a = e não é indexável).

O otimizador também pode utilizar um índice B-tree nos comandos envolvendo os operadores de correspondência com padrão LIKE, ILIKE, ~ e ~*, se o padrão estiver ancorado ao início da cadeia de caracteres como, por exemplo, em col LIKE ‘foo%’ ou col ~ ‘^foo’, mas não em col LIKE ‘%bar’. Entretanto, se o servidor não utilizar o idioma C, será necessário criar um índice com uma classe de operadores especial, para dar suporte a indexação de consultas com correspondência com padrão. Consulte a Seção 11.6 adiante.

A consulta abaixo mostra o idioma. [2]

=> \pset title Idioma
=> SELECT name, setting FROM pg_settings WHERE name LIKE 'lc%';

            Idioma
    name     |    setting
-------------+----------------
 lc_collate  | pt_BR.iso88591
 lc_ctype    | pt_BR.iso88591
 lc_messages | pt_BR.iso88591
 lc_monetary | pt_BR.iso88591
 lc_numeric  | pt_BR.iso88591
 lc_time     | pt_BR.iso88591
(6 linhas)

Os índices R-tree são adequados para consultas a dados espaciais. Para criar um índice R-tree deve ser utilizado um comando da forma:

CREATE INDEX nome ON tabela USING RTREE (coluna);

O planejador de comandos do PostgreSQL considera utilizar um índice R-tree sempre que a coluna indexada está envolvida em uma comparação utilizando um dos seguintes operadores:

<<
&<
&>
>>
@
~=
&&

(Consulte a Seção 9.10 para conhecer o significado destes operadores).

Os índices hash podem tratar apenas comparações de igualdade simples. O planejador de comandos do PostgreSQL considera utilizar um índice hash sempre que a coluna indexada está envolvida em uma comparação utilizando o operador =. O seguinte comando é utilizado para criar um índice hash:

CREATE INDEX nome ON tabela USING HASH (coluna);

Nota: Os testes mostraram que os índices hash do PostgreSQL não têm desempenho melhor do que os índices B-tree, e que o tamanho e o tempo de construção dos índices hash são muito piores. Por estas razões, desencoraja-se a utilização dos índices hash.

Os índices GiST não são um único tipo de índice, mas em vez disto uma infraestrutura dentro da qual podem sem implementadas muitas estratégias de indexação diferentes. Assim sendo, os operadores em particular com os quais o índice GiST pode ser utilizado variam dependendo da estratégia de indexação (a classe de operadores). Para obter mais informações consulte a Capítulo 49.

O método de índice B-tree é uma implementação das árvores B de alta-simultaneidade de Lehman-Yao. O método de índice R-tree implementa árvores R padrão utilizando o algoritmo de partição quadrática de Guttman. O método de índice hash é uma uma implementação do hashing linear de Litwin. São mencionados os algoritmos utilizados somente para indicar que todos estes métodos de índice são inteiramente dinâmicos, não necessitando de otimização periódica (como é o caso, por exemplo, dos métodos de acesso hash estáticos).

Notas

[1] hashing — valor de identificação produzido através da execução de uma operação numérica, denominada função de hashing, em um item de dado. O valor identifica de forma exclusiva o item de dado, mas exige um espaço de armazenamento bem menor. Por isso, o computador pode localizar mais rapidamente os valores de hashing que os itens de dado, que são mais extensos. Uma tabela de hashing associa cada valor a um item de dado exclusivo. Webster’s New World Dicionário de Informática, Brian Pfaffenberger, Editora Campus, 1999. (N. do T.)
[2] Exemplo escrito pelo tradutor, não fazendo parte do manual original.

Fonte: http://pgdocptbr.sourceforge.net/pg80/indexes-types.html

Restaurando backup com pg_restore

Restaurando backup com pg_restore

pg_restore —  restaura um banco de dados do PostgreSQL a partir de um arquivo gerado pelo pg_dump

Synopsis

pg_restore [ -a ] [ -c ] [ -C ] [ -d nome_bd ] [ -f arquivo_de_saída ] [ -F formato ] [ -i índice ] [ -l ] [ -L arquivo_da_listagem ] [ -N | -o | -r ] [ -O ] [ -P nome_da_função ] [ -R ] [ -s ] [ -S ] [ -t tabela ] [ -T gatilho ] [ -v ] [ -x ] [ -X palavra_chave] [ -h hospedeiro ] [ -p porta ] [ -U nome_do_usuário ] [ -W ] [ arquivo_de_exportação ]

Descrição:

O pg_restore é um utilitário para restaurar um banco de dados do PostgreSQL a partir de um arquivo gerado pelo pg_dump em um dos formatos não-texto-puro. São executados os comandos necessários para criar novamente todos os tipos, funções, tabelas, índices, agregações e operadores definidos pelo usuário, assim como os dados das tabelas.

Os arquivos de exportação contêm informações para o pg_restore reconstruir o banco de dados, mas também permitem ao pg_restore selecionar o que deve ser restaurado, ou mesmo reordenar a restauraração dos itens. Os arquivos de exportação são projetados para serem portáveis entre arquiteturas.

O pg_restore pode operar de dois modos: Se um nome de banco de dados for especificado, o arquivo de exportação é restaurado diretamente no banco de dados. Senão, um script contendo os comandos SQL necessários para reconstruir o banco de dados é criado (e escrito em um arquivo ou na saída padrão), semelhante aos scripts criados pelo pg_dump no formato texto-puro. Algumas das opções que controlam a criação do script são, portanto, análogas às opções do pg_dump.

Obviamente, o pg_restore não pode restaurar informações que não estejam presentes no arquivo de exportação; por exemplo, se o arquivo de exportação foi gerado usando a opção “exportar dados como INSERT”, o pg_restore não poderá importar os dados usando o comando COPY.
Opções

O pg_restore aceita os seguintes argumentos de linha de comando (As formas longas das opções estão disponíveis em algumas plataformas apenas).

nome_do_arquivo_exportado
Especifica a localização do arquivo de exportação a ser restaurado. Se não for especificado, a entrada padrão é usada.

-a
–data-only

Importa somente os dados, não o esquema (definições dos dados).

-c
–clean

Exclui (drop) os objetos do banco de dados antes de criá-los..

-C
–create

Cria o banco de dados antes de restaurá-lo (Quando esta opção está presente, o banco de dados designado por -d é usado apenas para executar o comando CREATE DATABASE inicial. Todos os dados são restaurados no banco de dados cujo nome aparece no arquivo de exportação).

-d nome_bd
–dbname=nome_bd

Conecta ao nome_bd e restaura diretamente no banco de dados. Os objetos grandes somente podem ser restaurados usando uma conexão direta ao banco de dados.

-f arquivo_de_saída
–file=arquivo_de_saída

Especifica o nome do arquivo contendo o script gerado, ou a listagem quando for utilizado com a opção -l. Por padrão a saída padrão.

-F formato
–format=formato

Especifica o formato do arquivo de exportação. Não é necessário especificar o formato, porque o pg_restore reconhece o formato automaticamente. Se for especificado, poderá ser um dos seguintes:

t

O arquivo de exportação está no formato tar. Este formato de arquivo de exportação permite reordenar e/ou excluir elementos do esquema durante a importação. Também permite limitar quais dados são recarregados durante a importação.

c

O arquivo de exportação está no formato personalizado do pg_dump. Este é o formato mais flexível porque permite a reordenação da importação dos dados e dos elementos do esquema. Este formato também é comprimido por padrão.

-i índice
–index=índice

Restaura a definição do índice para o índice especificado apenas.

-l
–list

Lista o conteúdo do arquivo de exportação. A saída deste comando pode ser usada com a opção -L para restringir e reordenar os itens que são restaurados.

-L arquivo_da_listagem
–use-list=arquivo_da_listagem

Restaura apenas os elementos presentes no arquivo_da_listagem, e na ordem em que aparecem neste arquivo. As linhas podem ser movidas e, também, podem virar comentário colocando-se um ; no seu início.

-N
–orig-order

Restaura os itens na ordem original de exportação. Por padrão, o pg_dump irá exportar os itens em uma ordem conveniente para o pg_dump, e depois salvar o arquivo de exportação em uma ordem de OID modificada. Esta opção substitui a da ordem de OID.

-o
–oid-order

Restaura os itens na ordem de OID. Por padrão o pg_dump irá exportar exporta os itens em uma ordem conveniente para o pg_dump, e depois salvar o arquivo de exportação em uma ordem de OID modificada. Esta opção impõe a estrita ordem de OID.

-O
–no-owner

Impede qualquer tentativa de restaurar o dono original do objeto. O dono dos objetos será o usuário conectado ao banco de dados.

-P nome_da_função
–function=nome_da_função

Especifica o procedimento ou a função a ser restaurada.

-r
–rearrange

Restaura os itens na ordem modificada de OID. Por padrão, o pg_dump irá exportar os itens em uma ordem conveniente para o pg_dump, e depois salvar o arquivo de exportação em uma ordem de OID modificada. A maior parte dos objetos é restaurada na ordem de OID, mas alguns elementos (por exemplo, regras e índices) são restaurados no fim do processo sem respeitar os OIDs. Esta é a opção padrão.

-R
–no-reconnect

Durante a restauração do arquivo de exportação, o pg_restore usualmente necessita reconectar ao banco de dados vária vezes com nomes de usuário diferentes, para definir o dono correto dos objetos criados. Se isto não for desejável (por exemplo, se a intervenção manual for necessária para cada reconexão), esta opção proíbe o pg_restore requisitar reconexões (uma requisição de conexão em modo texto-puro, não conectado ao banco de dados, é feita emitindo o comando \connect do psql). Entretanto, esta opção é um instrumento bastante rudimentar, porque faz o pg_restore perder a informação sobre o dono, a menos que seja usada a opção -X use-set-session-authorization.

-s
–schema-only

Restaura somente o esquema (definições dos dados), sem os dados. Os valores das seqüências são substituídos.

-S nome_do_usuário
–superuser=nome_do_usuário

Especifica o nome do superusuário a ser usado para desativar os gatilhos e/ou definir o dono dos elementos do esquema. Por padrão, o pg_restore usa o nome do usuário corrente se este for um superusuário.

-t tabela
–table=tabela

Restaurar o esquema/dados da tabela apenas.

-T gatilho
–trigger=gatilho

Restaurar a definição do gatilho apenas.

-v
–verbose

Especifica o modo verboso.

-x
–no-privileges
–no-acl

Proíbe a restauração dos privilégios de acesso (comandos GRANT/REVOKE).

-X use-set-session-authorization
–use-set-session-authorization

Normalmente, se ao restaurar um arquivo de exportação for necessário trocar o usuário corrente do banco de dados (por exemplo, para definir o dono correto do objeto), uma nova conexão ao banco de dados deve ser aberta, o que poderá requerer intervenção manual (por exemplo, senhas). Se for usada a opção -X use-set-session-authorization, então o pg_restore vai usar o comando SET SESSION AUTHORIZATION. Embora produza o mesmo efeito, requer que o usuário que for fazer a importação do banco de dados a partir do arquivo de exportação gerado seja um superusuário. Esta opção substitui a opção -R.

O pg_restore também aceita os seguintes argumentos de linha de comando para os parâmetros de conexão:

-h hospedeiro
–host=hospedeiro

Especifica o nome da máquina onde o servidor está executando. Se o nome iniciar por uma barra (/), é considerado como sendo o diretório do soquete do domínio Unix.

-p porta
–port=porta

Especifica a porta Internet TCP/IP, ou o soquete do domínio local Unix, onde o servidor está aguardando as conexões. O padrão para o número da porta é 5432, ou o valor da variável de ambiente PGPORT (se estiver definida).

-U nome_do_usuário

Nome do usuário para se conectar.

-W

Força a solicitação da senha. Deve acontecer automaticamente se o servidor requerer autenticação por senha.


Exemplos:

$ pg_restore -d bd_novo bd.tar

http://www.postgresql.org/docs/9.2/static/app-pgrestore.html