RSS

Arquivo da categoria: NoSQL

entendendo CouchDB beta paper

meu primeiro aqui no WP 🙂

vou adicionar um paper meu que preciso melhorar ortografia até por isso
está beta

Entendendo CouchDB
=========================
couchdb
Termo “Couch” é um acrônimo para “Cluster of Unreliable Commodity Hardware”
(Conjunto de Hardware Commodity Não-Confiáveis), “refletindo o objetivo
do banco de dados ser extremamente escalável, oferecendo alta disponibilidade
e confiabilidade, mesmo quando executando em um hardware que é tipicamente
suscetível a falhas”.

Em suma CouchDB é um banco de dados orientado a documentos, feito com “Erlang”
em conta de sua lendária programação multitarefa e desempenho,diferente de
bancos relacionais que estamos acostumados ver como MySQL,SQLite e PostgreSQL.

Da mesma forma que os SGBDRs oferecem o SQL como interface de
consulta, o CouchDB oferece uma interface de consultas adaptada aos
seus princípios arquiteturais baseados na Web,através do Representational
State Transfer (REST), que é utilizado como forma de inserir, atualizar,
extrair e remover dados do CouchDB.

Popularmente público rotula como NoSQL, este tipo de banco de dados assim
como “MongoDB”,muitos dizem que é errado pois usa SQL, mas este rótulo acabou
colando.

Quanto ao termo ACID no CouchDB, todo o layout de arquivos e sistema de
commit está baseado nestes princípios, o que resulta na garantia de um
estado sempre consistente do arquivo de banco de dados. A atualização de
documentos são serializadas e os leitores de banco nunca são bloqueados ou
nunca têm de esperar por escritores ou outros leitores. A leitura de documentos
pode ser realizada por diversos clientes sem ser bloqueada ou interrompida por
atualizações concorrentes. Esta característica se deve pela utilização de um
modelo baseado no algoritmo MVCC, onde cada cliente vê um retrato consistente
do banco de dados do começo até o final da operação de leitura.
(Apache CouchDB, Technical Overview, 2008)

*Antes de ir direto para prática vamos ao conceito REST

O REST utiliza um subconjunto de métodos disponíveis no protocolo
HTTP para realizar suas operações. De acordo com a especificação do
protocolo HTTP em (Fielding, et al., 2004) e a arquitetura definida por Fielding
(Fielding R. T., 2000), os métodos utilizados pelo REST são:

1. GET: uma operação de somente leitura. Esta operação é
idempotente e segura, significando que não importa a quantidade
de vezes que a operação seja aplicada, ou seja, o recurso seja lido,
o resultado deve ser sempre o mesmo. O ato de ler um documento
HTML não deve mudar o documento. Segura significa que            ao
invocar uma operação GET o estado do servidor não irá ser
alterado, ou seja, além da do consumo de recursos de CPU e
memória do servidor, nada mais será afetado (Burke, 2008);

2. PUT: geralmente relacionada com uma operação de inserção ou
atualização. Assim como o GET, também é idempotente, porém ao
usar o PUT, o cliente deve ter em mãos o recurso que está se
criando ou atualizando. A operação é idempotente pois ao enviar
mais de uma requisição não irá afetar o serviço em questão. Burke
(Burke, 2008) faz uma analogia com o processador de textos
Microsoft Word: “não importa a quantidade de vezes que você clica
no botão Salvar, o arquivo que será armazenado será logicamente
o mesmo documento”;

3. DELETE: utilizado para remover serviços. É idempotente, ao passo
que remover algo que já não está lá não é um problema;

4. POST: a única operação não idempotente e insegura do HTTP.
Este método não sofre muitas limitações exatamente para prover
ao sistema a possibilidade de executar outras operações fora do
contexto do GET (leitura), PUT (inserção e atualização) e DELETE
(remoção). No REST, é utilizada para modelar um serviço de
fabricação de objetos. Quando se usa o método PUT, sabe-se
exatamente o que está sendo criado, com o POST, é atribuído ao
servidor a tarefa de criar o objeto.

*Instalando o CouchDB

No linux

No meu debian foi tiro e quéda

apt-get install couchdb

No meu gentoo também

emerge -pv couchdb

fedora de um amigo do IRC

yum install couchdb

como eu não sei seus repositórios e nem sua distro vamos então

-requerimentos,caso use fedora troque apt-get por yum
$ sudo apt-get install automake autoconf libtool help2man
$ sudo apt-get install build-essential erlang libicu-dev libmozjs-dev  \
libcurl4-openssl-dev curl

-instalando o pacote na raça
$ wget http://apache.mirrors.esat.net/couchdb/0.10.0/apache-couchdb-0.10.0.tar.gz
$ tar xzvf apache-couchdb-0.10.0.tar.gz
$ cd apache-couchdb-0.10.0
$ ./configure
$ make
$ sudo make install
$ sudo adduser couchdb
$ sudo mkdir -p /usr/local/var/lib/couchdb
$ sudo mkdir -p /usr/local/var/log/couchdb
$ sudo mkdir -p /usr/local/var/run
$ sudo chown -R couchdb /usr/local/var/lib/couchdb
$ sudo chown -R couchdb /usr/local/var/log/couchdb
$ sudo chown -R couchdb /usr/local/var/run
$ sudo cp /usr/local/etc/init.d/couchdb /etc/init.d
$ sudo update-rc.d couchdb defaults
$ sudo /etc/init.d/couchdb start

*no MacOS e derivados de BSD procure pelos Ports

no MacOS por exemplo caso você não saiba o que é e não tenha
ports entre aqui http://www.macports.org/install.php
instale ports depois de o comando para instalar o couchdb

$ sudo port install couchdb curl

*no FreeBSD você pode usar “pkg_add -rv couchdb”

Bom tendo instalado o CouchDB tudo OK vamos ao teste

$ curl http://127.0.0.1:5984

como saida deve resultar “Wellcome do CouchDB”

Bom abra no seu navegador vamos ver o “Futon” gerenciador visual do
couchDB feito em javascript usando Jquery http://127.0.0.1:5984/_utils/index.html

Aberto o Futon vá para “test suite” e depois “Run” espere se tiver tudo OK sua instalação
não vai dar nenuma mensagem de erro. terminado o test não brinque agora com futon pois vamos
fazer testes práticos para entender algumas paradigmas…

Bom vamos usar o “Curl” para fazer comunicação com CouchDB assim
você entende a prática sem códigos longos em linguagens,estou
tentando ser mais transparente possível…

argvs do curl
“-d” usaremos para comunicação com JavaScript Object Notation (JSON)
“-X” usaremos para cominicação HTTP para enviar “GET,PUT,POST e DELETE.
“-v” isso é opcional caso queira ver os detalhes no modo de verbose

================== Comandos no Banco

criando banco chamado “contacts” e outro chamado “books”
curl -X PUT http://127.0.0.1:5984/contacts
curl -X PUT http://127.0.0.1:5984/books

listando todos os bancos
curl -X GET http://127.0.0.1:5984/_all_dbs

Deletar banco “books”
curl -X DELETE http://127.0.0.1:5984/books

para pegar informações do banco
curl -X GET http://127.0.0.1:5984/contacts

================== Comandos Documentos

criando documentos no banco exemplo “johndoe”
curl -X PUT http://127.0.0.1:5984/contacts/johndoe -d ‘{}’

caso queira ver o documento criado
curl -X GET http://127.0.0.1:5984/contacts/johndoe

caso queira deletar um documento especifico
curl -X DELETE http://127.0.0.1:5984/contacts/johndoe?rev=1-795358690

vamos criar um documento diferente com as hashs
{
“firstName”:”Joe”,
“lastName”:”Lennon”,
“email”:”joe@joelennon.ie”
}

curl -X PUT http://127.0.0.1:5984/contacts/joelennon -d ‘{“firstName”:\
“Joe”,”lastName”:”Lennon”,”email”:”joe@joelennon.ie”}’

então listamos…

curl -X GET http://127.0.0.1:5984/contacts/joelennon
{“_id”:”joelennon”,”_rev”:”1-
45597617″,”firstName”:”Joe”,”lastName”:”Lennon”,”email”:”joe@joelennon.ie”}

podemos vamos mudar o ID…
curl -X COPY http://127.0.0.1:5984/contacts/joelennon -H “Destination: johnsmith”
vendo o que foi criado
curl -X GET http://127.0.0.1:5984/contacts/johnsmith

agora seguindo outro documento

analisando a hash do JSON
{
“firstName”:”John”,
“lastName”:”Smith”,
“email”: [
“johnsmith@example.com”,
“jsmith@example.com”
],
“phone”:”(555) 555-5555″
}

curl -X PUT http://127.0.0.1:5984/contacts/johnsmith -d ‘{“_rev”:”1-
4152282996″,”firstName”:”John”,”lastName”:”Smith”,”email”:[“johnsmith@example.com”,”jsmith@e
xample.com”],”phone”:”(555) 555-5555″}’

================== Comandos VIEWs exemplos

Bom view seria um tipo de filtro para definirmos qual dos dados vão ser mostrados
vamos passar os dados

view sem filtro equivalente a um “select * from table”… em bancos relacionais
curl -X GET http://127.0.0.1:5984/contacts/_all_docs

agora usamos view com uma ordem
curl -X GET http://127.0.0.1:5984/contacts/_all_docs?descending=true

mesma view porem limitamos para apenas mostrar 1 documento
curl -X GET http://127.0.0.1:5984/contacts/_all_docs?descending=true\&limit=1

view que mostra todas as documentoss e seus conteudos
curl -X GET http://127.0.0.1:5984/contacts/_all_docs?include_docs=true

Uma view que lista documentos por ID em sequencia
curl -X GET http://127.0.0.1:5984/contacts/_all_docs_by_seq

================== Views na prática exemplo Blog

Bom agora sim você pode brincar no “Futon” hehehe

Bom leitor seguindo os exemplos você reparou que um simples javascript ínves
de comandos com “curl” pode trabalhar muito bem com CouchDB,você pode mesmo
fazer um blog só com javascript e couchdb sim é possível,Como não sou um
mestre em JavaScript demoraria muito para fazer tal feito mas posso mostrar
a teoria.

Estrutura de um documento de blog

{
“titulo”: “Este é um post no seu blog”,
“autor”: “mestre”,
“data”: “01/04/2010 12:38:00”,
“corpo”: “hoje estreando nosso blog com CouchDB “,
“comentarios”: [
{
“nome”: “curinga”,
“texto”: “Gostei muito do post!”,
“data”: “08/04/2010 2:31:09”
},
{
“nome”: “Fulano”,
“texto”: “Muito interessante, continue”,
“data”: “09/04/2010 1:17:31”
}
]
}

bom acessando http://localhost:5984/_utils/database.html?blog/_temp_view
podemos usar códigos javascripts para fazer um filtro  nos documentos

uma view para vermos apenas os comentários seria

function (doc){
if(doc.comentarios) emit(doc.comentarios, {texto: doc.texto});
}

agora uma view apenas para mostrar corpo do post

function (doc){
if(doc.corpo) emit(doc.corpo);
}

programação simples com javascript

agora vamos fazer listar somente o post do corpo criando uma view
procurando form “temporary view” você vai ver dois formularios para
sources

map function

function (doc){
if(doc.corpo) emit(doc.corpo);
}

reduce function

function(keys,values){
return keys;
}

clique no botão para salvar

irá aparecer dois formularios

escreva no primeiro “postcorpo”,segundo “corpopost” que seria nome da view

execute no navegador para verificar “http://localhost:5984/blog/_design/postcorpo/_view/corpopost”
veja sua View do documento personalizada listando somente “corpo” do POST

bom é isso ai posts futuros mais tarde…

 
Deixe um comentário

Publicado por em maio 9, 2010 em NoSQL