dot's questions

Informações básicas

Este é o primeiro dia para mim com couchbase. Eu revisei os bancos de dados de amostra usando o console de banco de dados que vem com o couchbase. Especificamente, tenho brincado com o aplicativo "amostra de cerveja" para tentar entender como organizar meu banco de dados. Parece que eles têm dois tipos diferentes de documentos - cervejarias ou cervejas - e tudo está no mesmo balde.

Para a minha candidatura pessoal, disponho dos seguintes dados:

{
  "server_details": {
    "name": "testserver",
    "dns_name": "testserver.mydomain.net",
    "ipv4": "10.xx.xx.xx",
    "ipv6": "",
    "type": "webserver"
  },
  "server_status": {
    "up_to_date": true
  },
  "packages": {
    "package1": {
      "current_version": "x.x",
      "previous_version": "x.x",
      "last_updated_on": "2016-03-16",
      "play_id": "link to audit table"
    },
    "package2": {
      "current_version": "x.x",
      "previous_version": "x.x",
      "last_updated_on": "2016-03-16",
      "play_id": "link to audit table"
    }
  }
}

Eu tenho diferentes tipos de servidor, como servidor web, appserver, servidor dns etc. Portanto, estou planejando usar apenas o mesmo objeto json, mas alterar o campo "tipo".

Pergunta

Também preciso criar algum tipo de tabela de auditoria que mostre o histórico de quando um pacote em um servidor foi atualizado. Preciso rastrear coisas como:

• data de execução
• nome do script
• package1_version_b4_update
• package1_version_after_update
• server_dns_name

Este é o objeto json que criei para este tipo de documento:

{
  "audit_details": {
    "script_name": "upgrade_all_mrts",
    "rt_ticket_number": "16123",
    "execution_date": "2016-03-16",
    "status": "success"
  },
  "affected_servers": {

    "server1": {     
      "package1":{
        "version_after_update": "x.x",
        "version_before_update": "x.x",
        "last_updated_on": "2016-03-16"
      },
      "package2": {
        "version_after_update": "x.x",
        "version_before_update": "x.x",
        "last_updated_on": "2016-03-16"
      }
   },
    "server2": {     
      "package1":{
        "version_after_update": "x.x",
        "version_before_update": "x.x",
        "last_updated_on": "2016-03-16"
      },
      "package2": {
        "version_after_update": "x.x",
        "version_before_update": "x.x",
        "last_updated_on": "2016-03-16"
      }
   }
  }
}

Seria este apenas mais um documento com uma estrutura completamente diferente? ou devo colocá-lo em outro balde? Se tudo deve estar no mesmo balde, a estrutura do objeto json que estou propondo é apropriada? Fundamentalmente, acho que minha pergunta é: você despeja tudo em um balde como uma coleção de documentos variados... e apenas certifica-se de que os documentos relacionados tenham a mesma estrutura para que você possa consultá-los todos de uma vez?

Desculpe pelas perguntas corretivas, mas estou tentando construir um protótipo em tempo real ... enquanto leio os documentos. Qualquer dica seria apreciada.

Eu tenho uma coleção de widgets que possui registros como este:

{ "_id" : ObjectId("55a6abe193819c033d4d755a"), "name" : "widget1"}
{ "_id" : ObjectId("55a6abe193819c033d4d755a"), "name" : "widget2", "loc" : ObjectId("55a69475da314d9984fc6201") }

Eu também tenho uma coleção de locais que se parece com isso:

{ "_id" : ObjectId("55a69475da314d9984fc6201"), "abbrev" : "CAN", "description" : "Canada" }
{ "_id" : ObjectId("55a6948eda314d9984fc6202"), "abbrev" : "USA", "description" : "United States" }
{ "_id" : ObjectId("55a69496da314d9984fc6203"), "abbrev" : "MEX", "description" : "Mexico" }

Se eu quiser encontrar todos os widgets localizados no Canadá, usando o Objectid, sei que posso fazer isso:

> db.widgets.find( { loc: ObjectId("55a69475da314d9984fc6201")})
{ "_id" : ObjectId("55a6abe193819c033d4d755a"), "name" : "widget2", "loc" : ObjectId("55a69475da314d9984fc6201") }

Mas e se eu quiser procurar locais não usando o objectid, mas a abreviação ou a descrição? Como eu faria isso?

Estou prestes a criar uma tabela pai e filho. Ao planejar como fazer operações CRUD nesses dados, eu queria saber qual é o melhor design quando se trata de excluir dados.

Estou usando o SQLite. Eu sei que com muitos bancos de dados, você pode configurar exclusões em cascata. Supondo que eu configurei os relacionamentos adequadamente para suportar esse tipo de recurso, minha dúvida é a seguinte:

É melhor usar o recurso de exclusão em cascata ao excluir registros pai ou posso continuar usando transações e excluir manualmente das tabelas pai/filho, com reversões quando algo falhar?

O front-end é um aplicativo da web. Qualquer sugestão / artigo que você possa me indicar seria ótimo.

Estou tentando me conectar a um banco de dados remoto psql. Antes de adicionar a entrada pg_hba.conf com o endereço IP do cliente, estava recebendo uma mensagem de erro:

xdev@xdevbox:~$ psql -U postgres testdb -h 10.1.1.47
psql: FATAL:  no pg_hba.conf entry for host "10.201.50.71", user "postgres", database "testdb", SSL off

Eu adicionei o IP do cliente com configurações de confiança. Eu também mudei o endereço de escuta em postgres.conf no servidor para escutar "*". Então reiniciei o servidor de banco de dados usando o comando /etc/init.d/postgresql restart.

Agora, quando tento conectar, recebo a seguinte mensagem de erro:

psql: could not connect to server: Connection refused
    Is the server running on host "10.1.1.47" and accepting
    TCP/IP connections on port 5432?

no postgresql.conf, a porta está definida como 5432. Não tenho certeza do que mais verificar.

Obrigado

Estou tentando executar este código no sqlite:

sqlite> CREATE TABLE test(id integer primary key AUTOINCREMENT, page varchar(10), dp_record_id integer, foreign key (webserver_id) REFERENCES target_dp(id));

Mas estou recebendo a seguinte mensagem de erro:

Erro: coluna desconhecida "webserver_id" na definição de chave estrangeira

Aqui está a tabela pai:

sqlite> .schema
CREATE TABLE target_dp(id integer primary key AUTOINCREMENT, server_name varchar(255), location_code varchar(10), active bit(1));
sqlite> 

Não consigo ver onde está o meu erro de sintaxe. Agradeço antecipadamente pelo seu tempo.

Estou executando o seguinte comando para criar um despejo de todos os bancos de dados no meu servidor de produção:

prodserver:/# pg_dumpall -U postgres -h 1.1.1.1 > prod.sql

na minha caixa de desenvolvimento, também faço um backup fazendo:

devserver:/# pg_dumpall -U postgres -h 1.1.1.1 > dev.sql

Então eu tento restaurar o banco de dados de produção para desenvolvimento da seguinte forma:

devserver:/# psql -f prod.sql -U postgres

Ele roda sem erros. E parece estar criando tabelas/importando dados. (Eu sei porque se eu executá-lo uma segunda vez, recebo mensagens de que certos dados já existem/já existem relacionamentos.)

Mas quando eu entro assim:

psql -U postgres -d databasename

os dados parecem iguais aos dados de desenvolvimento antigos.
Eu tentei o seguinte com os dados de produção supostamente restaurados:

select count(*) from widgets; 

Eu comparo isso com a contagem retornada quando estou usando o banco de dados de desenvolvimento e eles são os mesmos.

Eu também tentei reiniciar o postgresql depois de tentar a restauração ... é impossível.

Qualquer sugestão sobre o que posso estar fazendo de errado seria apreciada.

Obrigado.

EDITAR 1

Também verifiquei o seguinte:

Abri o arquivo prod.sql e encontrei instruções de inserção como:

INSERT INTO widgets_to_wiget_groups VALUES (363, 15);

E então fiz uma instrução select no banco de dados para ver se tinha essa entrada na tabela, mas não tenho ... talvez esteja restaurando, mas no contexto de outro usuário?

EDITAR 2

eu também tentei

 psql -f prod.sql -U postgres -h 1.1.1.1

mas ainda não funcionou Como teste, tentei restaurar o arquivo de despejo em outro novo servidor ... mesmos resultados. Então verifiquei e vi que no arquivo dump não existe o comando CREATE DATABASE. Estou pensando que o comando original para despejar o arquivo está incorreto ...

Quero saber se existe uma maneira de definir permanentemente o tamanho do meu cache de consulta e garantir que ele esteja sempre ativado. No momento, estou apenas usando o set global query_cache_sizecomando para definir o tamanho, mas quando o banco de dados é reiniciado, ele desaparece.