Last updated: Thu Oct 14 18:22:57 EDT 2004
-Current maintainer: Bruce Momjian <bruce@momjian.us>
-
The most recent version of this document can be viewed at -http://www.postgresql.org/docs/faqs.FAQ_MINGW.html.
- -The FAQ Running & Installing PostgreSQL On Native Windows is at -http://pginstaller.projects.postgresql.org/faq/FAQ_windows.html.
- -The native Win32 port is built from source using MinGW tools.
-There is also a precompiled binary installer called pginstaller which you can find at
-from http://pgfoundry.org/projects/pginstaller.
-It is a fully native build and uses no additional software like MinGW.
-The ready-made installer files are available on the main PostgreSQL ftp servers
-in the binary/win32 directory.
-
-
The native Win32 port requires a 32-bit NT-based Microsoft
-operating
-system, like Windows NT 4, Windows 2000/2003, or Windows XP. (NT 4
-is no longer supported since version 8.2) Earlier
-operating systems do not have sufficient infrastructure. Building the
-port also
-requires MinGW and Msys, which can be downloaded from http://www.mingw.org/. MinGW is
-a Unix-like build environment for Microsoft operating systems.
-Msys is a collection of unix tools required to run shell scripts like configure.
-Neither is required to run the resulting binaries; they are
-needed only for creating the binaries. Work is in progress to support
-building using Visual C++ in a future version.
-
Última atualização: Sex Nov 16 10:53:50 EST 2007
- -Mantenedor atual: Bruce Momjian (bruce@momjian.us) -
- -Traduzido por: Euler Taveira de Oliveira (euler@timbira.com)
- -A versão mais recente desse documento pode ser vista em
- http://www.postgresql.org/files/documentation/faqs/FAQ.html (EN).
-
- http://www.postgresql.org/files/documentation/faqs/FAQ_brazilian.html (pt_BR).
Perguntas sobre plataformas específicas são respondidas em http://www.postgresql.org/docs/faq/.
-PostgreSQL é pronunciado Post-Gres-Q-L. - (Para os curiosos que querem saber como se diz "PostgreSQL", um - arquivo de áudio está disponível).
- -O PostgreSQL é um sistema de banco de dados objeto-relacional que tem as - características de sistemas de bancos de dados comerciais tradicionais com - melhoramentos encontrados nos sistemas SGBDs de próxima geração. - PostgreSQL é livre e o código-fonte completo está disponível.
- -O desenvolvimento do PostgreSQL é feito por um grupo de desenvolvedores - voluntários (na sua maioria) espalhados pelo mundo e que se comunicam via - Internet. É um projeto da comunidade e não é controlado por nenhuma - empresa. Para se envolver, veja a FAQ do desenvolvedor em - http://www.postgresql.org/docs/faqs.FAQ_DEV.html -
- -Postgres é um apelido para o PostgreSQL amplamente utilizado. Era o nome original do - projeto em Berkeley e dentre os outros apelidos é o preferido. Se você acha - 'PostgreSQL' difícil de pronunciar, diga apenas 'Postgres'.
- -Se você está procurando por um mantenedor, comitê central ou empresa - controladora do PostgreSQL, desista --- não há um(a). Nós temos um - comitê core e committers CVS, mas estes grupos são mais para questões - administrativas do que controle. O projeto é direcionado pela comunidade - de desenvolvedores e usuários, que qualquer um pode se juntar. Tudo o que - você precisa é se inscrever nas listas de discussão e participar das - discussões. Veja a - FAQ do desenvolvedor para obter informações como se envolver com o - desenvolvimento do PostgreSQL.
- -O PostgreSQL é distribuído sob a licença BSD clássica. Basicamente, - ela permite que usuários façam qualquer coisa com o código, incluindo - revender os binários sem o código-fonte. A única restrição é que você - não nos responsabilize legalmente por problemas com o programa de computador. - Há também a exigência de que esta licença apareça em todas as cópias - do programa de computador. Aqui está a licença BSD que usamos atualmente:
-PostgreSQL está sujeito a seguinte licença:
- -PostgreSQL Data Base Management System
- -Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-1996 Regents of the University of California
- -Permission to use, copy, modify, and distribute this software - and its documentation for any purpose, without fee, and without a - written agreement is hereby granted, provided that the above - copyright notice and this paragraph and the following two - paragraphs appear in all copies.
- -IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL - DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS - SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF - CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- -THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE - SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE - UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, - SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- -Em geral, qualquer plataforma moderna compatível com Unix deve ser capaz de executar o PostgreSQL. As plataformas que foram testadas antes do lançamento de uma versão são listadas nas instruções de instalação.
- -O PostgreSQL também executa nativamente nos sistemas operacionais Microsoft Windows - baseados no NT tais como Win200 SP4, WinXP e Win2003. Um instalador pré-empacotado está - disponível em - http://pgfoundry.org/projects/pginstaller. Versões do Windows baseadas no MS-DOS - (Win95, Win98, WinMe) podem executar o PostgreSQL utilizando o Cygwin.
- -Há também uma versão para o Novell Netware 6 em - http://forge.novell.com - e uma versão para OS/2 (eComStation) em - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F.
- -Via navegador web, utilize - http://www.postgresql.org/ftp/ e via ftp, utilize - - ftp://ftp.postgresql.org/pub/.
- - -A última versão do PostgreSQL é a versão 8.2.5.
- -Nós planejamos lançar versões novas a cada ano com versões - corretivas em alguns meses.
- -A comunidade do PostgreSQL fornece assistência a muitos de seus - usuários via e-mail. O principal sítio web para inscrição nas listas - de e-mail é - http://www.postgresql.org/community/lists/. As listas general - e bugs são um bom lugar para início.
- -O principal canal de IRC é o #postgresql na Freenode (irc.freenode.net). Para se conectar você pode utilizar o comando Unix irc -c '#postgresql' "$USER" irc.freenode.net ou utilizar qualquer outro cliente de IRC. Um canal hispânico (#postgresql-es) e um francês (#postgresqlfr) também existem na mesma rede. Há também um canal PostgreSQL na EFNet.
Uma lista de empresas que prestam suporte comercial está disponível em - http://www.postgresql.org/support/professional_support.
- -Visite o formulário que reporta bugs do PostgreSQL em http://www.postgresql.org/support/submitbug.
-Verifique também o nosso ftp ftp://ftp.postgresql.org/pub para - ver se há uma versão mais recente do PostgreSQL.
- -Bugs submetidos utilizando o formulário ou informado a qualquer - lista de discussão do PostgreSQL tipicamente gera uma das seguintes - respostas:
-O PostgreSQL suporta um subconjunto extendido do SQL:2003. - Veja nossa lista de AFAZERES - que contém bugs conhecidos, funcionalidades ausentes e planos futuros.
- -Uma solicitação de funcionalidade geralmente resulta em uma das - seguintes respostas:
-O PostgreSQL não utiliza sistema de acompanhamento de bugs porque - nós achamos mais eficiente responder diretamente o e-mail e manter a - lista de AFAZERES - atualizada. Na prática, bugs não duram muito no programa; e bugs que afetam - uma grande quantidade de usuários são corrigidos rapidamente. O único lugar - para encontrar todas as mudanças, melhorias e correções em uma versão do - PostgreSQL é ler as mensagens de log do - CVS. Até mesmo - as notas de lançamento não listam todas as mudanças feitas no programa.
- -O PostgreSQL inclui vasta documentação, incluindo um manual extenso, - páginas de manuais (man pages) e alguns exemplos teste. Veja o diretório - /doc. Você também pode pesquisar os manuais online em http://www.postgresql.org/docs. -
- -Há dois livros sobre PostgreSQL disponíveis online em http://www.postgresql.org/docs/books/awbook.html - e http://www.commandprompt.com/ppbook/. - Há uma lista de livros sobre PostgreSQL disponíveis para compra. Um dos mais - populares é o do Korry Douglas. Uma lista de análise sobre os livros pode ser - encontrada em http://www.postgresql.org/docs/books/. - Há também uma coleção de artigos técnicos sbore PostgreSQL em http://www.postgresql.org/docs/techdocs/.
- -O programa cliente de linha de comando psql tem alguns comandos \d para - mostrar informações sobre tipos, operadores, funções, agregações, etc. - utilize \? - para mostrar os comandos disponíveis.
- -Nosso sítio web contém ainda mais documentação.
- -Primeiro, considere os livros específicos sobre PostgreSQL mencionados - acima. Muitos de nossos usuários gostam do The Practical SQL Handbook, - Bowman, Judith S., et al., Addison-Wesley. Outros do The - Complete Reference SQL, Groff et al., McGraw-Hill.
- -Há também bons tutoriais disponíveis online: -
Veja a - FAQ do Desenvolvedor.
- -Há várias maneiras de se medir um software: funcionalidades, performance, confiabilidade, suporte e preço.
- -Mudanças no horário de verão dos USA foram incluídas nas versões 8.0 .[4+] do PostgreSQL e em todas as versões grandes, i.e. 8.1. Mudanças no Canadá e Austrália Oeste foram incluídas na 8.0.[10+], 8.1.[6+] e em todas as versões grandes subsequentes. Versões do PostgreSQL anteriores a 8.0 utilizam o banco de dados de zona horária do sistema operacional para informações sobre horário de verão.
- -A instalação do PostgreSQL inclui somente as interfaces C e - C embutida. Todas as outras interfaces são projetos independentes - que podem ser obtidos separadamente; sendo separados permitem que eles tenham - suas próprias datas de lançamento e time de desenvolvedores.
- -Algumas linguagens de programação como PHP incluem uma - interface para PostgreSQL. Interfaces para linguagens como Perl, - TCL, Python e muitas outras estão disponíveis em - http://www.pgfoundry.org. -
- -Uma boa introdução para páginas web que utilizam bancos de dados pode ser vista em: - http://www.webreview.com
- -Para integração na Web, PHP (http://www.php.net) - é uma excelente interface.
- -Para casos complexos, muitos usam a Interface Perl e DBD::Pg com CGI.pm - ou mod_perl.
- -Há um vasto número de Ferramentas Gráficas (GUI), que estão disponíveis - para o PostgreSQL, comerciais e de desenvolvedores de código aberto. Uma - lista detalhada pode ser encontrada em - Documentação da Comunidade PostgreSQL
- -Especifique a opção --prefix quando executar o configure.
- -Por padrão, o PostgreSQL só permite conexões da máquina local utilizando soquetes de domínio Unix ou conexões TCP/IP. Outras máquinas não poderão conectar-se a menos que você modifique listen_addresses no postgresql.conf, habilite a autenticação por máquina modificando o arquivo $PGDATA/pg_hba.conf e reinicie o servidor PostgreSQL.
- -Há três grandes áreas para melhorar a performance em potencial:
- -Há muitas variáveis de configuração do servidor log_*
- que habilitam a exibição de consultas e estatísticas que podem ser
- muito úteis para depuração e medidas de performance.
Você atingiu o limite padrão de 100 sessões. Você - precisa aumentar o limite do servidor PostgreSQL, que diz - quantos processos servidor concorrentes ele pode iniciar, alterando - o valor max_connections no postgresql.conf e - reiniciando o postmaster.
- -Veja http://www.postgresql.org/support/versioning - para discusso geral sobre atualizaes e - http://www.postgresql.org/docs/current/static/install-upgrading.html - para instruções específicas.
- -Por causa do hardware de PC ser em sua maioria compatível, pessoas tendem a acreditar que todos os hardwares de PC são de mesma qualidade. Não é verdade. ECC RAM, SCSI e placas mãe de qualidade são mais confiáveis e têm uma melhor performance do que hardwares mais baratos. O PostgreSQL executará em quase todo hardware, mas se a confiabilidade e a performance forem importantes é prudente pesquisar sobre as opções de hardware. Nossas listas de discussão podem ser usadas para discutir opções de hardware e dilemas.
- -Para obter somente alguns registros, se você sabe o número de - registros necessários ao executar o SELECT utilize - o LIMIT. Se um índice corresponde no ORDER - BY é possível que a consulta toda não tenha que ser - executada. Se você não sabe o número de registros ao executar o - SELECT, utilize um cursor e o FETCH.
- -Para obter um registro randômico, utilize:
-- SELECT col - FROM tab - ORDER BY random() - LIMIT 1; -- -
Utilize o comando \dt para ver tabelas no psql. Para obter - uma lista completa dos comandos no psql você pode utilizar \?. - Alternativamente, você pode ler o código-fonte do psql no arquivo - pgsql/src/bin/psql/describe.c, ele contém os comandos SQL - que geram a saída para os comandos de contrabarra do psql. Você - também pode iniciar o psql com a opção -E para que as consultas - utilizadas para executar os comandos que você informou seja exibida. - O PostgreSQL também fornece uma inteface compatível com SQL do - INFORMATION SCHEMA que você pode consultar para obter informação sobre o - banco de dados.
- -Há também tabelas do sistema que começam com pg_ que os descrevem - também.
- -Utilizando o psql -l listará todos os bancos de dados.
- -Veja também o arquivo pgsql/src/tutorial/syscat.source. Ele - ilustra muitos dos comandos SELECTs necessários para obter - informação das tabelas de sistema do banco de dados.
- -Mudar o tipo de dado de uma coluna pode ser feito facilmente na versão 8.0 - ou superior com ALTER TABLE ALTER COLUMN TYPE.
- -Em versões anteriores, faça isso:
-- BEGIN; - ALTER TABLE tab ADD COLUMN col_nova novo_tipo_dado; - UPDATE tab SET col_nova = CAST(col_antiga AS novo_tipo_dado); - ALTER TABLE tab DROP COLUMN col_antiga; - COMMIT; --
Você pode então querer fazer um VACUUM FULL tab para recuperar - o espaço em disco utilizado pelos registros expirados.
- -Estes são os limites:
--- --
-- Tamanho máximo de um banco de dados? ilimitado (existem bancos de dados de 32 TB) - Tamanho máximo de uma tabela? 32 TB - Tamanho máximo de um registro? 400 GB - Tamanho máximo de um campo? 1 GB - Número máximo de registros em uma tabela? ilimitado - Número máximo de colunas em uma tabela? 250-1600 dependendo dos tipos das colunas - Número máximo de índices em uma tabela? ilimitado
É claro, que eles não são ilimitados, mas limitados - ao espaço em disco disponível e espaço em memória/swap. - A Performance será penalizada quando estes valores se tornarem grandes.
- -O tamanho máximo de uma tabela com 32 TB não requer suporte a - arquivos grandes do sistema operacional. Tabelas grandes são armazenadas - como múltiplos arquivos de 1 GB então o limite do sistema de - arquivos não é importante.
- -O tamanho máximo de uma tabela, o tamanho de um registro e o número - máximo de colunas podem ser quadruplicados aumentando-se o tamanho padrão - do bloco para 32k. O tamanho máximo de uma tabela pode também ser aumentado utilizando - particionamento de tabela.
- -Uma limitação é que índices não podem ser criados em colunas maiores do que - 2.000 caracteres. Felizmente, tais índices são raramente necessários. Unicidade é - melhor garantida por um índice de uma função de um hash MD5 de uma coluna longa, e - indexação de texto longo permite a busca de palavras dentro da coluna.
- -Um banco de dados PostgreSQL irá requerer até cinco vezes a quantidade de espaço requerida para armazenar dados em um arquivo texto.
- -Como um exemplo, considere um arquivo com 100.000 linhas contendo um inteiro e uma descrição em cada linha. Suponha que o tamanho médio da descrição é de vinte bytes. O arquivo terá 2,8 MB. O tamanho do arquivo do banco de dados PostgreSQL que contém esses dados pode ser estimado em 5,2 MB:
-- 24 bytes: cada cabeçalho de registro (aproximadamente) - 24 bytes: um campo int e um campo texto - + 4 bytes: ponteiro na página para a tupla - ------------------------------------------- - 52 bytes por registro - - O tamanho de uma página de dados no PostgreSQL é 8192 bytes (8 KB), então: - - 8192 bytes por página - ------------------------ = 158 registros por página do banco de dados (arredondado para baixo) - 52 bytes por registro - - 100000 registros de dados - ---------------------------- = 633 páginas do banco de dados (arredondado para cima) - 158 registros por página - -633 páginas do banco de dados * 8192 bytes por página = 5.185.536 bytes (5,2 MB) -- -
Índices não requerem muito espaço, mas contém - dados que foram indexados, então eles podem ocupar algum espaço.
- -NULLs são armazenados como bitmaps, então eles - utilizam muito pouco espaço.
- -Índices não são utilizados por toda consulta. Índices são utilizados somente - se a tabela é maior do que um tamanho mínimo, e a consulta seleciona somente uma - pequena porcentagem dos registros da tabela. Isto porque o acesso randômico ao - disco causado pela busca indexada pode ser mais lento do que uma leitura ao longo - da tabela ou busca sequencial.
- -Para determinar se um índice deveria ser utilizado, o PostgreSQL deve ter - estatísticas sobre a tabela. Estas estatísticas são coletadas utilizando o - VACUUM ANALYZE ou simplesmente o ANALYZE. - Utilizando estatísticas, o otimizador sbae quantos registros estão na tabela, - e pode melhor determinar se índices deveriam ser utilizados. - Estatísticas também são úteis para determinar a ordem de junção ótima e métodos - de junção. Coleção de estatísticas deveriam ser feitas periodicamente a - medida que o conteúdo da tabela muda.
- -Índices não são normalmente utilizados para ORDER BY ou para - fazer junções. Uma busca sequencial seguido por uma ordenação explícita é - geralmente mais rápida do que uma busca indexada em uma tabela grande. - Contudo, LIMIT combinado com ORDER BY - frequentemente utilizará índice porque somente uma pequena porção da tabela - será retornada.
- -Se você acredita que o otimizador está incorreto ao escolher uma busca
- sequencial, utilize SET enable_seqscan TO 'off' e execute a
- consulta novamente para ver se uma busca indexada é realmente mais rápida.
Ao utilizar operadores curinga tais como LIKE ou ~, - índices podem ser utilizados somente em algumas condições:
-text_pattern_ops para tais casos
- que funcionam somente para indexação com LIKE. Também é
- possível utilizar indexação de busca textual para buscas por palavras.
- Em versões anteriores a 8.0, índices frequentemente não podem ser utilizados - a menos que os tipos de dados correspondam aos tipos de coluna do índice. Isto era - particularmente verdadeiro para índices de coluna int2, int8 e numeric.
- -Veja o comando EXPLAIN no manual.
- -O operador ~ faz avaliação de expressões regulares, - e ~* faz avaliação não sensível a maiúsculas - de expressões regulares. A variante não sensível a maiúsculas - do LIKE é chamada de ILIKE.
- -Comparações de igualdade não sensíveis a maiúsculas - são normalmente expressadas como:
-- SELECT * - FROM tab - WHERE lower(col) = 'abc'; -- Isso não irá utilizar o índice padrão. Contudo, se - você criar um índice de expressão, ele será utilizado: -
- CREATE INDEX tabindex ON tab (lower(col)); --
Se o índice acima é criado como UNIQUE, embora a - coluna possa armazenar caracteres maiúsculos e minúsculos, ele não - pode ter valores idênticos que diferem apenas em letras maiúsculas e minúsculas. - Para forçar uma letra maiúscula ou minúscula a ser armazenada na coluna, utilize - uma restrição CHECK ou um gatilho.
- -Você testa a coluna com IS NULL e IS - NOT NULL, como a seguir:
- -- SELECT * - FROM tab - WHERE col IS NULL; -- -
Para concatenar com possíveis NULLs, utilize COALESCE(), assim:
-- SELECT COALESCE(col1, '') || COALESCE(col2, '') - FROM tab -- -
Para ordenar pelo status NULL, utilize os modificadores - IS NULL e IS NOT NULL na sua cláusula - ORDER BY. Coisas que são verdadeiro serão ordenadas acima - das coisas que são falso, então a consulta a seguir irá colocar - entradas NULL no início da lista de resultados:
- -- SELECT * - FROM tab - ORDER BY (col IS NOT NULL) -- -
-- --
-- Tipo Nome Interno Observação - VARCHAR(n) varchar tamanho especifica o tamanho -máximo, sem preenchimento - CHAR(n) bpchar preenchimento em branco para -comprimento fixo específico - TEXT text nenhum limite superior específico no -comprimento - BYTEA bytea vetor de bytes de comprimento variável -(seguro a byte nulo) - "char" char um caracter
Você verá o nome interno quando examinar o catálogo do sistema e em algumas mensagens de erro.
- -Os primeiros quatro tipos acima são do tipo "varlena" (i.e., os primeiros quatro bytes no disco são o comprimento seguido pelos dados). Consequentemente o espaço atual utilizado é ligeiramente maior do que o tamanho declarado. Contudo, valores longos são também sujeitos a compressão, então o espaço em disco pode também ser bem menor do que o esperado.
- - VARCHAR(n) é melhor quando está armazenando cadeias de caracteres de comprimento variável e há um limite de tamanho desta cadeia. TEXT é para cadeias de caracteres de comprimento ilimitado, com o máximo de um gigabyte. -CHAR(n) é para armazenar cadeias de caracteres que são todas do mesmo tamanho. CHAR(n) preenche com espaços em branco até o tamanho especificado, enquanto o VARCHAR(n) armazena somente os caracteres fornecidos. BYTEA é para armazenar dados binários, particularmente valores que incluem bytes NULL. Todos os tipos descritos aqui tem características de performance similares.
- -PostgreSQL suporta o tipo de dados SERIAL. Ele cria - automaticamente uma sequência. Por exemplo:
-- CREATE TABLE pessoa ( - id SERIAL, - nome TEXT - ); -- - é automaticamente traduzido em: -
- CREATE SEQUENCE pessoa_id_seq;
- CREATE TABLE pessoa (
- id INT4 NOT NULL DEFAULT nextval('pessoa_id_seq'),
- nome TEXT
- );
-
-
- Sequências automaticamente criadas são nomeadas como - <tabela>_<colunaserial>_seq, onde - tabela e colunaserial são os nomes da tabela e - da coluna serial, respectivamente. Veja a página sobre - create_sequence no manual para obter informações - adicionais sobre sequências. - -
A maneira mais simples de obter o próximo valor SERIAL - de uma sequência é com RETURNING. Utilizando o - exemplo da tabela em 4.11.1, ele ficaria assim: - -
- INSERT INTO pessoa (nome) VALUES ('Blaise Pascal') RETURNING id;
-
-
- Você também pode chamar nextval() e utilizar o valor no
- INSERT ou chamar currval() após o
- INSERT.
-
- Não. currval() retorna o valor atual atribuido pela sua sessão, e não por todas as sessões.
- -Para melhorar a concorrência, valores da sequência são atribuídos a transações correntes e não são travados até que a transação seja finalizada. Isso causa intervalos na numeração por causa de transações abortadas.
- -Se uma tabela é criada com WITH OIDS, cada registro recebe um OID único. - OIDs são automaticamente atribuídos como inteiros de 4 bytes - que são únicos ao longo de toda instalação. Contudo, eles são limitados em - 4 bilhões e, então, os OIDs começam a ser duplicados. O PostgreSQL - utiliza OIDs para ligar as tabelas do sistema.
- -Para numerar registros nas tabelas do usuários, é melhor utilizar - SERIAL ao invés de OIDs porque - sequências SERIAL são únicas somente em uma tabela; e - são menos propícias a atingir o limite. - SERIAL8 está disponível para armazenar valores de sequências - com oito bytes.
- -CTIDs são utilizados para identificar registros físicos - específicos com valores de block e deslocamento. CTIDs mudam - após registros serem modificados ou recarregados. Eles são utilizados por - índices para apontar registros físicos.
- -Você provavelmente está sem memória virtual no seu sistema, ou o seu núcleo (kernel) tem um limite baixo para certos recursos. Tente isto antes de iniciar o servidor PostgreSQL:
-- ulimit -d 262144 - limit datasize 256m -- - Dependendo da sua shell, somente um desses comando terá sucesso, mas ele definirá o segmento de dados do seu processo com um limite maior e talvez permita que a consulta seja feita. Este comando é aplicado ao processo atual e todos os subprocessos criados depois do comando ser executado. Se você tiver problemas com o cliente SQL porque o processo servidor retornou muitos dados, tente-o antes de iniciar o cliente. - -
No psql, digite SELECT version();
Utilize CURRENT_TIMESTAMP:
-- CREATE TABLE teste (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP ); -- -
PostgreSQL suporta junções externas utilizando a sintaxe padrão do SQL. Aqui temos dois exemplos:
-- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -- or -
- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- -
Essas duas consultas indênticas juntam t1.col com t2.col, e também - retornam qualquer registro que não foi juntado em t1 (aqueles que não - combinaram com t2). Uma junção a direita RIGHT - adicionaria registros que não foram juntados da tabela t2. - Uma junção completa (FULL) retornaria os registros - combinados mais todos os registros não combinados de t1 e t2. - A palavra OUTER é opcional e é assumida nas - junções LEFT, RIGHT e FULL. - Junções ordinárias são chamadas junções - internas (INNER).
- -Não há outra maneira de consultar um banco de dados caso ele - não seja o atual. Porque o PostgreSQL carrega catálogos do sistema - específicos do banco de dados, é incerto como uma consulta em banco - de dados distintos pode se comportar.
- -contrib/dblink permite consultas em bancos de dados distintos utilizando - chamadas de funções. É claro, que um cliente pode fazer - conexões simultâneas em bancos de dados diferentes e juntar os - resultados no cliente.
- -É fácil utilizando funções que retornam conjunto, - - http://www.postgresql.org/docs/techdocs.17.
- -Em versões do PostgreSQL < 8.3, PL/PgSQL armazena o conteúdo da função, e o efeito indesejado é que se uma função PL/PgSQL acessa uma tabela temporária, e aquela tabela é removida e criada novamente, e a função é chamada novamente, a função irá falhar porque o conteúdo armazenado da função ainda apontará para a tabela temporária antiga. A solução é utilizar o EXECUTE para acesso a tabelas temporárias no PL/PgSQL. Isto irá fazer com que a consulta seja avaliada toda vez.
- -Este problema não ocorre no PostgreSQL 8.3 ou superior.
- -Embora "replicação" seja um termo simples, há várias tecnologias para fazer - replicação, com vantagens e desvantagens para cada um.
- -Replicação mestre/escravo permite que um mestre receba consultas de leitura e - escrita, enquanto os escravos só podem aceitar leitura/consultas SELECT. - A solução mais popular de replicação mestre-escravo para PostgreSQL disponível livremente - é Slony-I.
- -Replicação com múltiplos mestres permite que consultas leitura/escrita sejam - enviadas para múltiplos computadores replicadores. Esta capacidade também tem - um sério impacto na performance por causa da necessidade de sincronizar as mudanças - entre os servidores. PGCluster - é a solução mais popular disponível livremente para PostgreSQL.
- -Há também soluções de replicação comerciais e baseadas em hardware disponíveis - que suportam uma variedade de modelos de replicação.
- -A causa mais comum de nomes desconhecidos é o uso de aspas ao redor dos nomes da tabela ou coluna - durante a criação da tabela. Ao utilizar aspas, nomes de tabela e coluna - (chamados de identificadores) são armazenados - como especificado, significando que você deve utilizar aspas quando se - referir aos nomes na consulta. Algumas interfaces, como pgAdmin, - automaticamente colocam aspas nos identificadores durante a criação da tabela. - Então, para identificadores serem reconhecidos, você deve: -
最近更新：2007 年 1 月 30 日 星期二 17:37:01 EST
- 中文版最近更新：2007 年 2 月 1 日 星期四 12:55:04 CST
-
目前维护人员：Bruce Momjian (pgman@candle.pha.pa.us)
- 中文版维护人员：Daojing.Zhou（doudou586@gmail.com）
-
- 本文档的最新版本可以在 - http://www.postgresql.org/files/documentation/faqs/FAQ.html查看。 -
-
- 与操作系统平台相关的问题可在http://www.postgresql.org/docs/faq/里找到答案。
-
-1.1)PostgreSQL 是什么？该怎么发音？
-1.2)谁控制和管理PostgreSQL ？
-1.3)PostgreSQL的版权是什么？
-1.4)PostgreSQL可以运行在哪些操作系统平台上？
-1.5)我从哪里能得到PostgreSQL？
-
-1.6)最新版的PostgreSQL 是什么？
-1.7)我从哪里能得到对PostgreSQL 的支持？
-1.8)我如何提交一个BUG报告？
-1.9)我如何了解已知的 BUG 或暂缺的功能？
-1.10)能够获取的最新文档有哪些？
-1.11)我应该怎样学习 SQL ？
-
-1.12)如何提交补丁或是加入开发队伍？
-1.13)PostgreSQL 和其他数据库系统比起来如何？
-1.14)PostgreSQL 可以处理最近各个国家夏时制的变化吗？
-
-2.1)我们可以用什么语言和PostgreSQL 打交道？
-2.2)有什么工具可以把PostgreSQL 用于 Web 页面？
-
-2.3)PostgreSQL 拥有图形用户界面吗？
-
-3.1)我怎样才能把PostgreSQL 装在 /usr/local/pgsql 以外的地方？
-3.2)我如何控制来自其他电脑的连接？
-3.3)我怎样调整数据库服务器以获得更好的性能？
-
-3.4)PostgreSQL 里可以获得什么样的调试特性？
-3.5)为什么在试图连接登录时收到“Sorry, too many clients” 消息？
-3.6)PostgreSQL的升级过程有哪些内容？
-3.7)(使用PostgreSQL)我需要使用什么计算机硬件 ？
-
-4.1) 如何只选择一个查询结果的头几行？或是随机的一行？
-4.2) 如何查看表、索引、数据库以及用户的定义？如何查看psql里用到的查询指令并显示它们？
-4.3) 如何更改一个字段的数据类型？
-4.4) 单条记录，单个表，一个数据库的最大限制是多少？
-4.5) 存储一个典型的文本文件里的数据需要多少磁盘空间？
-
-4.6) 为什么我的查询很慢？为什么这些查询没有利用索引？
-4.7) 我如何才能看到查询优化器是怎样评估处理我的查询的？
-4.8) 我怎样做正则表达式搜索和大小写无关的正则表达式查找？怎样利用索引进行大小写无关查找？
-4.9) 在一个查询里，我怎样检测一个字段是否为 NULL？我如何才能准确排序而不论某字段是否含NULL值？
-4.10) 各种字符类型之间有什么不同？
-4.11.1) 我怎样创建一个序列号型或是自动递增的字段？
-
-4.11.2) 我如何获得一个插入的序列号的值？
-4.11.3) 同时使用 currval() 会导致和其他用户的冲突情况吗？
-4.11.4) 为什么不在事务异常中止后重用序列号呢？为什么在序列号字段的取值中存在间断呢？
-4.12) 什么是 OID？什么是 CTID ？
-4.13) 为什么我收到错误信息“ERROR: Memory exhausted in AllocSetAlloc()”？
-
-4.14) 我如何才能知道所运行的 PostgreSQL 的版本？
-4.15) 我如何创建一个缺省值是当前时间的字段？
-4.16) 如何执行外连接（outer join）查询？
-4.17) 如何执行涉及多个数据库的查询？
-4.18) 如何让函数返回多行或多列数据？
-4.19) 为什么我在使用PL/PgSQL函数存取临时表时会收到错误信息“relation with OID ##### does not exist”？
-
-4.20) 目前有哪些数据复制方案可用？
-4.21) 为何查询结果显示的表名或列名与我的查询语句中的不同？为何大写状态不能保留？
-
PostgreSQL 读作 Post-Gres-Q-L，有时候也简称为Postgres 。想听一下其发音的人员可从这里下载声音文件： - MP3 格式 。 -
- -PostgreSQL 是面向目标的关系数据库系统，它具有传统商业数据库系统的所有功能，同时又含有将在下一代 DBMS 系统的使用的增强特性。PostgreSQL 是自由免费的，并且所有源代码都可以获得。 -
- -PostgreSQL 的开发队伍主要为志愿者，他们遍布世界各地并通过互联网进行联系，这是一个社区开发项目，它不被任何公司控制。 - 如想加入开发队伍，请参见开发人员常见问题（FAQ） - http://www.postgresql.org/files/documentation/faqs/FAQ_DEV.html - -
- -- 如果你在寻找PostgreSQL的掌门人，或是什么中央委员会，或是什么所属公司，你只能放弃了---因为一个也不存在，但我们的确有一个 - 核心委员会和CVS管理组，但这些工作组的设立主要是为了进行管理工作而不是对PostgreSQL进行独占式控制，PostgreSQL项目是由任何人均 - 可参加的开发人员社区和所有用户控制的，你所需要做的就是订阅邮件列表，参与讨论即可（要参与PostgreSQL的开发详见 - 开发人员常问题 (Developer's FAQ) 获取信息）。 -
- - -PostgreSQL的发布遵从经典的BSD版权。它允许用户不限目的地使用PostgreSQL，甚至你可以销售PostgreSQL而不含源代码也可以，唯一的限制就是你不能因软件自身问题而向我们追诉法律责任，另外就是要求所有的软件拷贝中须包括以下版权声明。下面就是我们所使用的BSD版权声明内容：
- -PostgreSQL数据库管理系统
- -部分版权（c）1996-2005，PostgreSQL 全球开发小组，部分版权（c）1994-1996 加州大学董事
- -（Portions copyright (c) 1996-2005,PostgreSQL Global Development Group Portions Copyright (c) 1994-6 Regents of the University of California）
- -- 允许为任何目的使用，拷贝，修改和分发这个软件和它的文档而不收取任何费用， - 并且无须签署因此而产生的证明，前提是上面的版权声明和本段以及下面两段文字出现在所有拷贝中。 - -
- -- （Permission to use, copy, modify, and distribute this software and its - documentation for any purpose, without fee, and without a written agreement is - hereby granted, provided that the above copyright notice and this paragraph and - the following two paragraphs appear in all copies.） -
- -- 在任何情况下，加州大学都不承担因使用此软件及其文档而导致的对任何当事人的直接的， - 间接的，特殊的，附加的或者相伴而生的损坏，包括利益损失的责任，即使加州大学已经建议了这些损失的可能性时也是如此。 -
- -- （IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR - DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST - PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF - THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH - DAMAGE.） -
- - -- 加州大学明确放弃任何保证，包括但不局限于某一特定用途的商业和利益的隐含保证。 - 这里提供的这份软件是基于“当作是”的基础的，因而加州大学没有责任提供维护，支持，更新，增强或者修改的服务。 -
- -
- （THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
- NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
- THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE,
- SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.）
-
-
一般说来，任何现在对 UNIX 兼容的操作系统之上都能运行PostgreSQL 。在安装指南里列出了发布时经过明确测试的平台。
- - -PostgreSQl也可以直接运行在基于微软Windows-NT的操作系统，如Win2000 SP4，WinXP 和 Win2003，已制作完成的安装包可从 - http://pgfoundry.org/projects/pginstaller下载，基于MSDOS的Windows操作系统 - （Win95，Win98，WinMe）需要通过Cygwin模拟环境运行PostgreSQL。 -
- -- 同时也有一个为Novell Netware 6开发的版本可从 http://forge.novell.com获取，为OS/2(eComStation)开发的版本可从 - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F 下载。 - -
- -- 通过浏览器可从http://www.postgresql.org/ftp/下载，也可通过FTP，从 - ftp://ftp.PostgreSQL.org/pub/站点下载。 -
- -PostgreSQL 最新的版本是版本 8.2.1 。
- -我们计划每年发布一个主要升级版本，每几个月发布一个小版本。
- - -PostgreSQL社区通过邮件列表为其大多数用户提供帮助，订阅邮件列表的主站点是 http://www.postgresql.org/community/lists/，一般情况下，先加入General 或 Bug邮件列表是一个较好的开始。 -
- -- 主要的IRC频道是在FreeNode(irc.freenode.net)的#postgresql，为了连上此频道，可以使用UNIX程序irc，其指令格式： - irc -c '#postgresql' "$USER" irc.freenode.net ，或者使用其他IRC客户端程序。在此网络中还存在一个PostgreSQL的西班牙频道(#postgersql-es)和法语频道 - (#postgresql-fr)。同样地，在EFNET上也有一个PostgreSQL的交流频道。 -
- -- 可提供商业支持的公司列表可在http://techdocs.postgresql.org/companies.php浏览。 - -
- - - -- 可访问 http://www.postgresql.org/support/submitbug，填写Bug上报表格即可，同样也可访问ftp站点ftp://ftp.PostgreSQL.org/pub/ 检查有无更新的PostgreSQL版本或补丁。 -
- - --通过使用Bug提交表格或是发往PostgreSQL邮件列表的Bug通常会有以下之一回复： -
- -PostgreSQL 支持一个扩展的 SQL:2003 的子集。参阅我们的TODO 列表，了解已知Bug列表、暂缺的功能和将来的开发计划。 - -
- -要求增加新功能的申请通常会收到以下之一的回复：
- --PostgreSQL不使用Bug跟踪系统，因为我们发现在邮件列表中直接回复以及保证TODO任务列表总是处于最新状态的方式工作效率会更高一些。事实上，Bug不会在我们的软件中存在很长时间， -对影响很多用户的Bug也总是很快会被修正。唯一能找到所有改进、提高和修正的地方是CVS的日志信息，即使是在软件新版本的发布信息中也不会列出每一处的软件更新。 -
- - - -PostgreSQL包含大量的文档，主要有详细的参考手册，手册页和一些的测试例子。参见 /doc 目录（译注：应为 $PGHOME/doc）。 - 你还可以在线浏览PostgreSQL的手册，其网址是：http://www.PostgreSQL.org/docs。 -
- -- 有两本关于PostgreSQL的书在线提供，在 - http://www.PostgreSQL.org/docs/awbook.html - 和 http://www.commandprompt.com/ppbook/ 。 - 也有大量的PostgreSQL书籍可供购买，其中最为流行的一本是由Korry Douglas编写的。在 - http://techdocs.PostgreSQL.org/techdocs/bookreviews.php上 - 上有大量有关PostgreSQL书籍的简介。 - 在 http://techdocs.PostgreSQL.org/上收集了有关PostgreSQL的大量技术文章。 - -
- -- 客户端的命令行程序psql有一些以 \d 开头的命令，可显示关于类型，操作符，函数，聚合等信息，使用 \? 可以显示所有可用的命令。 -
- -- 我们的 web 站点包含更多的文档。 -
- - - -- 首先考虑上述提到的与PostgreSQL相关的书籍，另外一本是Teach Yourself SQL in 21 Days, Second Edition，其详细介绍的网址是 - http://members.tripod.com/er4ebus/sql/index.htm， - 我们的许多用户喜欢The Practical SQL Handbook， Bowman, Judith S. 编写，Addison-Wesley公司出版，其他的则喜欢 - The Complete Reference SQL, Groff 编写，McGraw-Hill公司出版。 -
- -在下列网址上也有很好的教程，他们是
-- 详见 开发人员常见问题 (Developer's FAQ) 。 - -
- - --评价软件有好几种方法：功能，性能，可靠性，支持和价格。 -
- -PostgreSQL 8.0之前的版本是使用操作系统中的时区数据库来处理夏时制的信息，自8.0版及以后的版本PostgreSQL会自身含有最新的时区信息。
- - -PostgreSQL(缺省情况)只安装有C和内嵌式C的接口，其他的接口都是独立的项目，能够分别下载，这些接口项目独立的好处 - 是他们可以有各自的发布计划和各自独立的开发组。 -
-- 一些编程语言如PHP都有访问PostgreSQL的接口，Perl、TCL、Python以及很多其他语言的接口在 - http://gborg.postgresql.org网站上的Drivers/Interfaces小节可找到， - 并且通过Internet很容易搜索到。 -
- - - - -- 一个介绍以数据库为后台的挺不错的站点是：http://www.webreview.com。 -
-- 对于 Web 集成，PHP 是一个极好的接口。它在http://www.php.net/。 - -
-- 对于复杂的任务，很多人采用 Perl 接口和 使用CGI.pm的DBD::Pg 或 mod_perl 。 -
- - -- 商业用户或是开源开发人员能找到很多的有关PostgreSQL的GUI图形工具软件，在 PostgreSQL社区文档有一个详细的列表。 -
- - -- 在运行 configure 时加上 --prefix 选项。 -
- - - -- 缺省情况下，PostgreSQL只允许来自本机且通过 unix 域套接字或TCP/IP方式的连接。 - 你只有在修改了配置文件postgresql.conf中的listen_addresses，且也在配置文件$PGDATA/pg_hba.conf中打开了 - 基于远程电脑（ host-based ）的身份认证，并重新启动PostgreSQL，否则其他电脑是不能与你的PostgreSQL服务器进行连接的。 -
- - -- 有三个主要方面可以提升PostgreSQL的潜能。 -
- -PostgreSQL 有很多类似 log_* 的服务器配置变量可用于查询的打印和进程统计，而这些工作对调试和性能测试很有帮助。
-
- 这表示你已达到缺省100个并发后台进程数的限制，你需要通过修改postgresql.conf文件中的max_connections值来 - 增加postmaster的后台并发处理数，修改后需重新启动postmaster。 - -
- - -- PostgreSQL 开发组对每次小版本的升级主要只做了一些Bug修正工作，因此从 7.4.8 升级到 7.4.9 不需要 dump 和 restore，仅需要停止数据库服务器，安装更新后的软件包，然后重启服务器即可。 -
-- 所有PostgreSQL的用户应该在最接近（你所使用的主版本）的小改进版本发布尽快升级。尽管每次升级可能都有一点风险，PostgreSQL的小改进版仅仅是设计用来修正一些Bug的，代码改动较少，所以风险还是很小的。PostgreSQL社区认为一般情况下不升级的风险还是多于升级的。 -
-- 主版本的升级（例如从 7.3 到 7.4）通常会修改系统表和数据表的内部格式。 - 这些改变一般比较复杂，因此我们不维持数据文件的向后兼容性。因此从老版本中进行数据导出（dump）/然后在新版本中进行数据导入（reload）对主版本的升级是必须的。 - -
- -- 由于计算机硬件大多数是兼容的，人们总是倾向于相信所有计算机硬件质量也是相同的。事实上不是， - ECC RAM（带奇偶校验的内存），SCSI （硬盘）和优质的主板比一些便宜货要更加可靠且具有更好的性能。PostgreSQL几乎可以运行在任何硬件上， - 但如果可靠性和性能对你的系统很重要，你就需要全面的研究一下你的硬件配置了。在我们的邮件列表上也有关于 - 硬件配置和性价比的讨论。 -
- - -- 如果你只是要提取几行数据，并且你在执行查询中知道确切的行数，你可以使用LIMIT功能。 - 如果有一个索引与 ORDER BY中的条件匹配，PostgreSQL 可能就只处理要求的头几条记录， - （否则将对整个查询进行处理直到生成需要的行）。如果在执行查询功能时不知道确切的记录数， - 可使用游标(cursor)和FETCH功能。 -
-- 可使用以下方法提取一行随机记录的： -
-- SELECT cols - FROM tab - ORDER BY random() - LIMIT 1 ; - -- - - -
- 在psql中使用 \dt 命令来显示数据表的定义，要了解psql中的完整命令列表可使用\? ，另外，你也可以阅读 psql 的源代码 - 文件pgsql/src/bin/psql/describe.c，它包括为生成psql反斜杠命令的输出的所有 SQL 命令。你还可以带 -E 选项启动 psql， - 这样它将打印出你在psql中所给出的命令执行时的内部实际使用的SQL查询语句。PostgreSQL也提供了一个兼容SQL的INFORMATION SCHEMA接口， - 你可以从这里获取关于数据库的信息。 - -
-- 在系统中也有一些以pg_ 打头的系统表也描述了表的定义。 -
-- 使用 psql -l 指令可以列出所有的数据库。 -
-- 也可以浏览一下 pgsql/src/tutorial/syscat.source文件，它列举了很多可从数据库系统表中获取信息的SELECT语法。 - -
- - -- 在8.0版本里更改一个字段的数据类型很容易，可使用 ALTER TABLE ALTER COLUMN TYPE 。 -
-- 在以前的版本中，可以这样做： -
-- BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; - --
- 你然后可以使用VACUUM FULL tab 指令来使系统收回无效数据所占用的空间。 -
- -- 下面是一些限制： -
--- - -- - -
-- 单个数据库最大尺寸？ 无限制（已存在有 32TB 的数据库） - 单个表的最大尺寸？ 32 TB - 一行记录的最大尺寸？ 1.6 TB - - 一个字段的最大尺寸? 1 GB - 一个表里最大行数？ 无限制 - 一个表里最大列数？ 250-1600 （与列类型有关） - - 一个表里的最大索引数量？ 无限制
- 当然，实际上没有真正的无限制，还是要受可用磁盘空间、可用内存/交换区的制约。 - 事实上，当上述这些数值变得异常地大时，系统性能也会受很大影响。 -
- -- 单表的最大大小 32 TB 不需要操作系统对单个文件也需这么大的支持。大表用多个 1 GB 的文件存储，因此文件系统大小的限制是不重要的。 -
-- 如果缺省的块大小增长到 32K ，最大的单表大小和最大列数还可以增加到四倍。 -
-- 有一个限制就是不能对大小多于2000字节的列创建索引。幸运地是这样的索引很少用到。通过对多字节列的内容进行MD5哈稀运算结果进行函数索引可对列的唯一性得到保证， - 并且全文检索允许对列中的单词进行搜索。 -
- - -- 一个 Postgres 数据库（存储一个文本文件）所占用的空间最多可能需要相当于这个文本文件自身大小5倍的磁盘空间。 -
-- 例如，假设有一个 100,000 行的文件，每行有一个整数和一个文本描述。 - 假设文本串的平均长度为20字节。文本文件占用 2.8 MB。存放这些数据的PostgreSQL数据库文件大约是 6.4 MB: -
-- 28 字节: 每行的头（大约值） - 24 字节: 一个整数型字段和一个文本型字段 - + 4 字节: 页面内指向元组的指针 - ---------------------------------------- - 56 字节每行 - - PostgreSQL 数据页的大小是 8192 字节 (8 KB)，则： - - 8192 字节每页 - ------------------- = 146 行/数据页（向下取整） - 56 字节每行 - - 100000 数据行 - -------------------- = 685 数据页（向上取整） - 146 行/数据页 - - 685 数据页 * 8192 字节/页 = 5,611,520 字节（5.6 MB） -- - -
- 索引不需要这么多的额外消耗，但也确实包括被索引的数据，因此它们也可能很大。 -
-- 空值NULL存放在位图中，因此占用很少的空间。 -
- -- 并非每个查询都会自动使用索引。只有在表的大小超过一个最小值，并且查询只会选中表中较小比例的记录时才会采用索引。 - 这是因为索引扫描引起的随即磁盘存取可能比直接地读取表（顺序扫描）更慢。 - -
-- 为了判断是否使用索引，PostgreSQL必须获得有关表的统计值。这些统计值可以使用 VACUUM ANALYZE，或 ANALYZE 获得。 - 使用统计值，优化器知道表中有多少行，就能够更好地判断是否利用索引。 - 统计值对确定优化的连接顺序和连接方法也很有用。在表的内容发生变化时，应定期进行统计值的更新收集。 -
-- 索引通常不用于 ORDER BY 或执行连接。对一个大表的一次顺序扫描再做一次排序通常比索引扫描要快。然而，如果将 LIMIT 和 ORDER BY - 结合在一起使用的话，通常将会使用索引，因为这时仅返回表中的一小部分记录。 -
-
- 如果你确信PostgreSQL的优化器使用顺序扫描是不正确的，你可以使用SET enable_seqscan TO 'off'指令来关闭顺序扫描，
- 然后再次运行查询，你就可以看出使用一个索引扫描是否确实要快一些。
-
- - 当使用通配符操作，例如 LIKE 或 ~ 时，索引只能在特定的情况下使用： -
-text_pattern_ops索引来用于LIKE的索引。
- - 在8.0之前的版本中，除非要查询的数据类型和索引的数据类型相匹配，否则索引经常是未被用到，特别是对int2,int8和数值型的索引。 -
- -参考 EXPLAIN 手册页。
- -- 操作符 ~ 处理正则表达式匹配，而 ~* 处理大小写无关的正则表达式匹配。大小写无关的 LIKE 变种成为 ILIKE。 - -
-- 大小写无关的等式比较通常写做： -
-- SELECT * - FROM tab - WHERE lower(col) = 'abc'; -- -
- 这样将不会使用标准的索引。但是可以创建一个在这种情况下使用的表达式索引: -
-- CREATE INDEX tabindex ON tab (lower(col)); - --
- 如果上述索引在创建时加入UNIQUE约束，虽然索引字段自身内容可以存储大小写不限的内容，但如果有UNIQUE约束后，这些内容不能仅仅是大小写不同（否则会造成冲突）。为了保证不发生这种情况，可以使用CHECK约束条件或是触发器在录入时进行限制。 -
- - -- - 用 IS NULL 和 IS NOT NULL 测试这个字段，具体方法如下： -
-SELECT * - FROM tab - WHERE col IS NULL; -- -
为了能对含 NULL字段排序，可在 ORDER BY 条件中使用 IS NULL和 - IS NOT NULL 修饰符，条件为真 true 将比条件为假false 排在前面，下面的例子就会将含 - NULL 的记录排在结果的上面部分： - -
-SELECT * - FROM tab - ORDER BY (col IS NOT NULL) -- -
-- -- -
-- - 类型 内部名称 说明 - VARCHAR(n) varchar 指定了最大长度，变长字符串，不足定义长度的部分不补齐 - CHAR(n) bpchar 定长字符串，实际数据不足定义长度时，以空格补齐 - TEXT text 没有特别的上限限制（仅受行的最大长度限制） - - BYTEA bytea 变长字节序列（使用NULL字符也是允许的） - - "char" char 单个字符
- 在系统表和在一些错误信息里你将看到内部名称。 -
-- 上面所列的前四种类型是"varlena"（变长）类型（也就是说，开头的四个字节是长度，后面才是数据）。 - 于是实际占用的空间比声明的大小要多一些。 - 然而这些类型如定义很长时都可以被压缩存储，因此磁盘空间也可能比预想的要少。 - -
-- VARCHAR(n) 在存储限制了最大长度的变长字符串是最好的。 - TEXT 适用于存储最大可达 1G左右但未定义限制长度的字符串。 -
-- CHAR(n) 最适合于存储长度相同的字符串。 CHAR(n)会根据所给定的字段长度以空格补足（不足的字段内容）， - 而 VARCHAR(n) 只存储所给定的数据内容。 - BYTEA 用于存储二进制数据，尤其是包含 NULL 字节的值。这些类型具有差不多的性能。 - -
- - - -PostgreSQL 支持 SERIAL 数据类型。（字段定义为SERIAL后）将自动创建一个序列生成器，例如： -
-- CREATE TABLE person ( - id SERIAL, - name TEXT - ); --
- 会自动转换为以下SQL语句： -
- -
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
-
-- 参考 create_sequence 手册页获取关于序列生成器的更多信息。 -
- - -- 一种方法是在插入之前先用函数 nextval() 从序列对象里检索出下一个 SERIAL 值，然后再用此值精确地插入。使用 - 4.11.1 里的例表，可用伪码这样描述： - -
-
- new_id = execute("SELECT nextval('person_id_seq')");
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
-
-- 这样还能在其他查询中使用存放在 new_id 里的新值（例如，作为参照 person 表的外键）。 - 注意自动创建的 SEQUENCE 对象的名称将会是 <table>_<serialcolumn>_seq， - 这里 table 和 serialcolumn 分别是你的表的名称和你的 SERIAL 字段的名称。 -
-- 类似的，在 SERIAL 对象缺省插入后你可以用函数 currval() 检索刚赋值的 SERIAL 值，例如： - -
-
- execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
- new_id = execute("SELECT currval('person_id_seq')");
-
-
-
- 不会。currval() 返回的是你本次会话进程所赋的值而不是所有用户的当前值。
-
-
- 为了提高并发性，序列号在需要的时候赋予正在运行的事务，并且在事务结束之前不进行锁定， - 这就会导致异常中止的事务后，序列号会出现间隔。 -
- -PostgreSQL 里创建的每一行记录都会获得一个唯一的OID，除非在创建表时使用WITHOUT OIDS选项。 - OID创建时会自动生成一个4字节的整数，所有 OID 在相应PostgreSQL服务器中均是唯一的。 然而，它在超过40亿时将溢出， - OID此后会出现重复。PostgreSQL 在它的内部系统表里使用 OID 在表之间建立联系。 -
-- 在用户的数据表中，最好是使用SERIAl来代替OID - - 因为SERIAL只要保证在单个表中的数值是唯一的就可以了，这样它溢出的可能性就非常小了， - SERIAL8可用来保存8字节的序列数值。 -
- -- CTID 用于标识带着数据块（地址）和（块内）偏移的特定的物理行。 - CTID 在记录被更改或重载后发生改变。索引数据使用它们指向物理行。 -
- - - -- 这很可能是系统的虚拟内存用光了，或者内核对某些资源有较低的限制值。在启动 postmaster 之前试试下面的命令： -
-- ulimit -d 262144 - limit datasize 256m --
- 取决于你用的 shell，上面命令只有一条能成功，但是它将把你的进程数据段限制设得比较高， - 因而也许能让查询完成。这条命令应用于当前进程，以及所有在这条命令运行后创建的子进程。 - 如果你是在运行SQL客户端时因为后台返回了太多的数据而出现问题，请在运行客户端之前执行上述命令。 - -
- -
- 从 psql 里，输入 SELECT version();指令。
-
- 使用 CURRENT_TIMESTAMP： - -
-- CREATE TABLE test (x int, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- - -
PostgreSQL 采用标准的 SQL 语法支持外连接。这里是两个例子：
-- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); --
或是
- -- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); --
- 这两个等价的查询在 t1.col 和 t2.col 上做连接，并且返回 t1 中所有未连接的行（那些在 t2 中没有匹配的行）。 - 右[外]连接（RIGHT OUTER JOIN）将返回 t2 中未连接的行。 - 完全外连接（FULL OUTER JOIN）将返回 t1 和 t2 中未连接的行。 - 关键字 OUTER 在左[外]连接、右[外]连接和完全[外]连接中是可选的，普通连接被称为内连接（INNER JOIN）。 -
- - -- 没有办法查询当前数据库之外的数据库。 - 因为PostgreSQL要加载与数据库相关的系统目录（系统表），因此跨数据库的查询如何执行是不定的。 -
- -- 附加增值模块contrib/dblink允许采用函数调用实现跨库查询。当然用户也可以同时连接到不同的数据库执行查询然后在客户端合并结果。 -
- -- 在函数中返回数据记录集的功能是很容易使用的，详情参见： - http://techdocs.postgresql.org/guides/SetReturningFunctions -
- -- PL/PgSQL会缓存函数的脚本内容，由此带来的一个不好的副作用是若一个 PL/PgSQL - 函数访问了一个临时表，然后该表被删除并重建了，则再次调用该函数将失败， - 因为缓存的函数内容仍然指向旧的临时表。解决的方法是在 PL/PgSQL 中用EXECUTE - 对临时表进行访问。这样会保证查询在执行前总会被重新解析。 -
- -- “复制”只是一个术语，有好几种复制技术可用，每种都有优点和缺点： -
-- - 主/从复制方式是允许一个主服务器接受读/写的申请，而多个从服务器只能接受读/SELECT查询的申请， - 目前最流行且免费的主/从PostgreSQL复制方案是 - Slony-I 。 -
-- 多个主服务器的复制方式允许将读/写的申请发送给多台的计算机，这种方式由于需要在多台服务器之间同步数据变动 - 可能会带来较严重的性能损失，Pgcluster是目前这种方案 - 中最好的，而且还可以免费下载。 -
-- 也有一些商业需付费和基于硬件的数据复制方案，支持上述各种复制模型。 -
- - -- 最常见的原因是在创建表时对表名或是列名使用了双引号“”，当使用了双引号后，表名或列名（称为标识符）存储时是区分 -大小写的， - 这意谓着你在查询时表名或列名也应使用双引号，一些工具软件，像pgAdmin会在发出创建表的指令时自动地在每个标识符上加双引号。 - 因此，为了标识符的统一，你应该： -
- 最近更新：2007 年 2 月 8 日 星期二 22:43:13 EST
- 中文版最近更新：2007 年 2 月 12 日 星期一 12:00:04 CST
-
當前維護人員：Bruce Momjian (pgman@candle.pha.pa.us)
- 正體中文版維護人員：郭朝益(ChaoYi, Kuo)（kuo.chaoyi@gmail.com）
- 本文檔的最新版本可以在 - http://www.postgresql.org/files/documentation/faqs/FAQ.html 查看。 -
-
- 與作業系統平台相關的問題可在 http://www.postgresql.org/docs/faq/ 裡找到答案。
-
-1.1)PostgreSQL 是什麼？該怎麼發音？
-1.2)誰控制和管理PostgreSQL ？
-1.3)PostgreSQL的版權是什麼？
-1.4)PostgreSQL可以運行在哪些作業系統平台上？
-1.5)我從哪裡能得到PostgreSQL？
-
-1.6)最新版的 PostgreSQL 是什麼？
-1.7)我從哪裡能得到對 PostgreSQL 的支持？
-1.8)我如何提交一個 BUG 報告？
-1.9)我如何瞭解已知的 BUG 或暫缺的功能？
-1.10)能夠獲取的最新文檔有哪些？
-1.11)我應該怎樣學習 SQL ？
-
-1.12)如何提交補丁或是加入開發隊伍？
-1.13)PostgreSQL 和其他資料庫系統比起來如何？
-1.14)PostgreSQL 可以處理最近各個國家夏時制的變化嗎？
-
-2.1)我們可以用什麼語言和 PostgreSQL 進行溝通？
-2.2)有什麼工具可以把 PostgreSQL 用於 Web 頁面？
-
-2.3)PostgreSQL 擁有圖形用戶界面(GUI)嗎？
-
-3.1)我怎樣才能把 PostgreSQL 裝在 /usr/local/pgsql 以外的地方？
-3.2)我如何控制來自其他電腦的連接？
-3.3)我怎樣調整資料庫伺服器以獲得更好的性能？
-
-3.4)PostgreSQL 裡可以獲得什麼樣的調試特性？
-3.5)為什麼在試圖連接登錄時收到「Sorry, too many clients」 訊息？
-3.6)PostgreSQL 的升級過程有哪些內容？
-3.7)(使用 PostgreSQL )我需要使用什麼電腦硬體？
-
-4.1) 如何只選擇一個查詢結果的頭幾行？或是隨機的一行？
-4.2) 如何查看表、索引、資料庫以及用戶的定義？如何查看 psql 裡用到的查詢指令並顯示它們？
-4.3) 如何更改一個欄位的資料類型？
-4.4) 單筆記錄，單一表，一個資料庫的最大限制是多少？
-4.5) 存儲一個典型的文本文件裡的資料需要多少磁碟空間？
-
-4.6) 為什麼我的查詢很慢？為什麼這些查詢沒有利用索引？
-4.7) 我如何才能看到查詢優化器是怎樣評估處理我的查詢的？
-4.8) 我怎樣做正則表達式搜索和大小寫無關的正則表達式查找？怎樣利用索引進行大小寫無關查找？
-4.9) 在一個查詢裡，我怎樣檢測一個欄位是否為 NULL？我如何才能準確排序而不論某欄位是否含NULL值？
-4.10) 各種字符類型之間有什麼不同？
-4.11.1) 我怎樣創建一個序列號型或是自動遞增的欄位？
-
-4.11.2) 我如何獲得一個插入的序列號的值？
-4.11.3) 同時使用 currval() 會導致和其他用戶的衝突情況嗎？
-4.11.4) 為什麼不在事務異常中止後重用序列號呢？為什麼在序列號欄位的取值中存在間斷呢？
-4.12) 什麼是 OID？什麼是 CTID ？
-4.13) 為什麼我收到錯誤資訊「ERROR: Memory exhausted in AllocSetAlloc()」？
-
-4.14) 我如何才能知道所運行的 PostgreSQL 的版本？
-4.15) 我如何創建一個預設值是當前時間的欄位？
-4.16) 如何執行外連接（outer join）查詢？
-4.17) 如何執行涉及多個資料庫的查詢？
-4.18) 如何讓函數返回多行或多列資料？
-4.19) 為什麼我在使用 PL/PgSQL 函數存取臨時表時會收到錯誤資訊「relation with OID ##### does not exist」？
-
-4.20) 目前有哪些資料複寫(replication)方案可用？
-4.21) 為何查詢結果顯示的表名或欄名與我的查詢語句中的不同？為何大寫狀態不能保留？
-
PostgreSQL 讀作 Post-Gres-Q-L，有時候也簡稱為Postgres 。想聽一下其發音的人員可從這裡下載聲音文件： - MP3 格式 。 -
- -PostgreSQL 是面向目標的關係資料庫系統，它具有傳統商業資料庫系統的所有功能，同時又含有將在下一代 DBMS 系統的使用的增強特性。PostgreSQL 是自由免費的，並且所有源代碼都可以獲得。 -
- -PostgreSQL 的開發隊伍主要為志願者，他們遍佈世界各地並通過互聯網進行聯繫，這是一個社區開發項目，它不被任何公司控制。 - 如想加入開發隊伍，請參見開發人員常見問題（FAQ） - http://www.postgresql.org/files/documentation/faqs/FAQ_DEV.html - -
- -- 如果你在尋找PostgreSQL的掌門人，或是什麼中央委員會，或是什麼所屬公司，你只能放棄了---因為一個也不存在，但我們的確有一個 - 核心委員會和CVS管理組，但這些工作組的設立主要是為了進行管理工作而不是對PostgreSQL進行獨佔式控制，PostgreSQL項目是由任何人均 - 可參加的開發人員社區和所有用戶控制的，你所需要做的就是訂閱郵件列表，參與討論即可（要參與PostgreSQL的開發詳見 - 開發人員常問題 (Developer's FAQ) 獲取資訊）。 -
- - -部分版權（c）1996-2005，PostgreSQL 全球開發小組，部分版權（c）1994-1996 加州大學董事
- - - -- 允許為任何目的使用，拷貝，修改和分發這個軟體和它的文檔而不收取任何費用， - 並且無須簽署因此而產生的證明，前提是上面的版權聲明和本段以及下面兩段文字出現在所有拷貝中。 - -
- - - - - - - - -- 加州大學明確放棄任何保證，包括但不局限於某一特定用途的商業和利益的隱含保證。 - 這裡提供的這份軟體是基於「當作是」的基礎的，因而加州大學沒有責任提供維護，支持，更新，增強或者修改的服務。 -
- - - -一般說來，任何現在對 UNIX 相容的作業系統之上都能運行 PostgreSQL 。在安裝指南裡列出了發佈時經過明確測試的平台。
- - -PostgreSQL 也可以直接運行在基於微軟 Windows-NT 的作業系統，如 Win2000 SP4，WinXP 和 Win2003，已製作完成的安裝包可從 - http://pgfoundry.org/projects/pginstaller下載，基於MSDOS的Windows作業系統 - （Win95，Win98，WinMe）需要通過Cygwin模擬環境運行PostgreSQL。 -
- -- 同時也有一個為 Novell Netware 6 開發的版本可從 http://forge.novell.com 獲取，為OS/2(eComStation)開發的版本可從 - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F 下載。 - -
- -- 通過瀏覽器可從 http://www.postgresql.org/ftp/ 下載，也可通過FTP，從 - ftp://ftp.PostgreSQL.org/pub/ 站點下載。 -
- -PostgreSQL社區通過郵件列表為其大多數用戶提供幫助，訂閱郵件列表的主站點是 http://www.postgresql.org/community/lists/，一般情況下，先加入General 或 Bug郵件列表是一個較好的開始。 -
- -- 主要的IRC頻道是在FreeNode(irc.freenode.net)的#postgresql，為了連上此頻道，可以使用 UNIX 程序 irc，其指令格式： - irc -c '#postgresql' "$USER" irc.freenode.net ，或者使用其他IRC客戶端程序。在此網絡中還存在一個 PostgreSQL 的西班牙頻道(#postgersql-es)和法語頻道 - (#postgresql-fr)。同樣地，在 EFNET 上也有一個 PostgreSQL 的交流頻道。 -
- -- 可提供商業支持的公司列表可在 http://techdocs.postgresql.org/companies.php 瀏覽。 - -
- - - -- 可訪問 http://www.postgresql.org/support/submitbug，填寫 Bug 上報表格即可，同樣也可訪問 ftp 站點 ftp://ftp.PostgreSQL.org/pub/ 檢查有無更新的PostgreSQL 版本或補丁。 -
- - --通過使用 Bug 提交表格或是發往 PostgreSQL 郵件列表的 Bug 通常會有以下之一回覆： -
- -PostgreSQL 支持一個擴展的 SQL:2003 的子集。參閱我們的 TODO 列表，瞭解已知 Bug 列表、暫缺的功能和將來的開發計劃。 - -
- -要求增加新功能的申請通常會收到以下之一的回覆：
- --PostgreSQL 不使用 Bug 跟蹤系統，因為我們發現在郵件列表中直接回覆以及保證 TODO 任務列表總是處於最新狀態的方式工作效率會更高一些。事實上，Bug不會在我們的軟體中存在很長時間， -對影響很多用戶的Bug也總是很快會被修正。唯一能找到所有改進、提高和修正的地方是 CVS 的日誌資訊，即使是在軟體新版本的發布資訊中也不會列出每一處的軟體更新。 -
- - - -PostgreSQL 包含大量的文檔，主要有詳細的參考手冊，手冊頁和一些的測試例子。參見 /doc 目錄（譯註：應為 $PGHOME/doc）。 - 你還可以在線瀏覽 PostgreSQL 的手冊，其網址是：http://www.PostgreSQL.org/docs。 -
- -- 有兩本關於PostgreSQL的書在線提供，在 - http://www.postgresql.org/docs/books/awbook.html - 和 http://www.commandprompt.com/ppbook/ 。 - 也有大量的 PostgreSQL 書籍可供購買，其中最為流行的一本是由 Korry Douglas 編寫的。在 - http://techdocs.PostgreSQL.org/techdocs/bookreviews.php上 - 上有大量有關 PostgreSQL 書籍的簡介。 - 在 http://techdocs.PostgreSQL.org/ 上收集了有關 PostgreSQL 的大量技術文章。
- -- 客戶端的命令行程序psql有一些以 \d 開頭的命令，可顯示關於類型，操作符，函數，聚合等資訊，使用 \? 可以顯示所有可用的命令。 -
- -- 我們的 web 站點包含更多的文檔。 -
- - - -- 首先考慮上述提到的與PostgreSQL相關的書籍，另外一本是 Teach Yourself SQL in 21 Days, Second Edition，其詳細介紹的網址是 - http://members.tripod.com/er4ebus/sql/index.htm， - 我們的許多用戶喜歡The Practical SQL Handbook， Bowman, Judith S. 編寫，Addison-Wesley公司出版，其他的則喜歡 - The Complete Reference SQL, Groff 編寫，McGraw-Hill 公司出版。 -
- -在下列網址上也有很好的教程，他們是
-- 詳見 開發人員常見問題 (Developer's FAQ) 。
- - --評價軟體有好幾種方法：功能，性能，可靠性，支持和價格。 -
- - - - -PostgreSQL 8.0之前的版本是使用作業系統中的時區資料庫來處理夏時制的資訊，自 8.0 版及以後的版本 PostgreSQL 會自身含有最新的時區資訊。
- - -PostgreSQL (預設情況)只安裝有 C 和內嵌式 C 的接口，其他的接口都是獨立的項目，能夠分別下載，這些接口項目獨立的好處 - 是他們可以有各自的發布計劃和各自獨立的開發組。 -
-- 一些編程語言如 PHP 都有訪問 PostgreSQL 的接口，Perl、TCL、Python 以及很多其他語言的接口在 - http://gborg.postgresql.org 網站上的 Drivers/Interfaces 小節可找到， - 並且通過 Internet 很容易搜索到。 -
- - - - -- 一個介紹以資料庫為後台的挺不錯的站點是：http://www.webreview.com。 -
-- 對於 Web 集成，PHP 是一個極好的接口。它在 http://www.php.net/。 - -
-- 對於複雜的任務，很多人採用 Perl 接口和 使用 CGI.pm 的 DBD::Pg 或 mod_perl 。 -
- - -- 商業用戶或是開源開發人員能找到很多的有關 PostgreSQL的GUI 圖形工具軟體，在 PostgreSQL社區文檔 有一個詳細的列表。 -
- - -- 在運行 configure 時加上 --prefix 選項。 -
- - - -- 有三個主要方面可以提升 PostgreSQL 的潛能。 -
- -PostgreSQL 有很多類似 log_* 的伺服器配置變量可用於查詢的列印和進程統計，而這些工作對調試和性能測試很有幫助。
-
SELECT cols - FROM tab - ORDER BY random() - LIMIT 1 ; - -- - - -
- 在系統中也有一些以 pg_ 打頭的系統表也描述了表的定義。 -
- -- 也可以瀏覽一下 pgsql/src/tutorial/syscat.source 文件，它列舉了很多可從資料庫系統表中獲取資訊的SELECT語法。 - -
- - -- 在8.0版本裡更改一個欄位的資料類型很容易，可使用 ALTER TABLE ALTER COLUMN TYPE 。 -
- -BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; - --
- 你然後可以使用 VACUUM FULL tab 指令來使系統收回無效資料所佔用的空間。 -
- --- - -- - -
-- 單個資料庫最大尺寸？ 無限制（已存在有 32TB 的資料庫） - 單個表的最大尺寸？ 32 TB - 一行記錄的最大尺寸？ 1.6 TB - - 一個欄位的最大尺寸? 1 GB - -一個表裡最大列數？ -無限制 - -一個表裡最大欄位數？ -250-1600 （與列類型有關） - - 一個表裡的最大索引數量？ 無限制
- 當然，實際上沒有真正的無限制，還是要受可用磁盤空間、可用記憶體/交換區的制約。 - 事實上，當上述這些數值變得異常地大時，系統性能也會受很大影響。 -
- -- 單表的最大大小 32 TB 不需要作業系統對單個文件也需這麼大的支持。大表用多個 1 GB 的文件存儲，因此文件系統大小的限制是不重要的。 -
-- 如果預設的塊大小增長到 32K ，最大的單表大小和最大列數還可以增加到四倍。 -
- - - -- 一個 Postgres 資料庫（存儲一個文本文件）所佔用的空間最多可能需要相當於這個文本文件自身大小5倍的磁盤空間。 -
- -24 字元組: 每行的頭（大約值） - 24 字元組節: 一個整數型欄位和一個文本型欄位 - + 4 字元組節: 頁面內指向元組的指針 - ---------------------------------------- - 52 字元組每行 - - PostgreSQL 資料頁的大小是 8192 位元組 (8 KB)，則： - - 8192 字元組每頁 - ------------------- = 158 行/資料頁（向下取整） - 52 字元組每行 - - 100000 資料行 - -------------------- = 633 資料頁（向上取整） - 146 行/資料頁 - - 633 資料頁 * 8192 字節/頁 = 5,185,536 字節（5.2 MB） -- - -
- 索引不需要這麼多的額外消耗，但也確實包括被索引的資料，因此它們也可能很大。 -
- - -- 並非每個查詢都會自動使用索引。只有在表的大小超過一個最小值，並且查詢只會選中表中較小比例的記錄時才會採用索引。 - 這是因為索引掃瞄引起的隨即磁盤存取可能比直接地讀取表（順序掃瞄）更慢。 - -
- - - - -- - 當使用通配符操作，例如 LIKE 或 ~ 時，索引只能在特定的情況下使用： -
-text_pattern_ops 索引來用於 LIKE 的索引。
- - 在 8.0 之前的版本中，除非要查詢的資料類型和索引的資料類型相匹配，否則索引經常是未被用到，特別是對 int2, int8 和數值型的索引。 -
- -- 操作符 ~ 處理正則表達式匹配，而 ~* 處理大小寫無關的正則表達式匹配。大小寫無關的 LIKE 變種成為 ILIKE。 - -
- -SELECT * - FROM tab - WHERE lower(col) = 'abc'; -- -
- 這樣將不會使用標準的索引。但是可以創建一個在這種情況下使用的表達式索引: -
-CREATE INDEX tabindex ON tab (lower(col)); - -- - - -
- - 用 IS NULL 和 IS NOT NULL 測試這個欄位，具體方法如下： -
-SELECT * - FROM tab - WHERE col IS NULL; -- - -
SELECT * - FROM tab - ORDER BY (col IS NOT NULL) -- -
-- - - -- -
-- - 類型 -內部名稱 -說明 -- VARCHAR(n) varchar 指定了最大長度，變長字符串，不足定義長度的部分不補齊 - CHAR(n) bpchar 定長字符串，實際資料不足定義長度時，以空格補齊 - TEXT text 沒有特別的上限限制（僅受行的最大長度限制） - - BYTEA bytea 變長字節序列（使用NULL字符也是允許的） - - "char" char 單個字符
- VARCHAR(n) 在存儲限制了最大長度的變長字符串是最好的。 - TEXT 適用於存儲最大可達 1G 左右但未定義限制長度的字符串。 -
- - - - -PostgreSQL 支持 SERIAL 資料類型。（欄位定義為SERIAL後）將自動創建一個序列生成器，例如： -
-CREATE TABLE person ( - id SERIAL, - name TEXT - ); -- - -
CREATE SEQUENCE person_id_seq; - CREATE TABLE person ( - id INT4 NOT NULL DEFAULT nextval('person_id_seq'), - name TEXT - ); --
- 參考 create_sequence 手冊頁獲取關於序列生成器的更多資訊。 -
- - -- 一種方法是在插入之前先用函數 nextval() 從序列對象裡檢索出下一個 SERIAL 值，然後再用此值精確地插入。使用 - 4.11.1 裡的例表，可用偽碼這樣描述： - -
- new_id = execute("SELECT nextval('person_id_seq')");
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
-
-- 這樣還能在其他查詢中使用存放在 new_id 裡的新值（例如，作為參照 person 表的外鍵）。 - 注意自動創建的 SEQUENCE 對象的名稱將會是 <table>_<serialcolumn>_seq， - 這裡 table 和 serialcolumn 分別是你的表的名稱和你的 SERIAL 欄位的名稱。 -
-- 類似的，在 SERIAL 對象預設插入後你可以用函數 currval() 檢索剛賦值的 SERIAL 值，例如： - -
- execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
- new_id = execute("SELECT currval('person_id_seq')");
-
-
-
- 不會。currval() 返回的是你本次會話進程所賦的值而不是所有用戶的當前值。
-
-
- 為了提高併發性，序列號在需要的時候賦予正在運行的事務，並且在事務結束之前不進行鎖定， - 這就會導致異常中止的事務後，序列號會出現間隔。 -
- -- CTID 用於標識帶著資料塊（地址）和（塊內）偏移的特定的物理行。 - CTID 在記錄被更改或重載後發生改變。索引資料使用它們指向物理行。 -
- - - -- 這很可能是系統的虛擬內存用光了，或者內核對某些資源有較低的限制值。在啟動 postmaster 之前試試下面的命令： -
-ulimit -d 262144 - limit datasize 256m -- - -
- 從 psql 裡，輸入 SELECT version();指令。
-
CREATE TABLE test (x int, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- - -
PostgreSQL 採用標準的 SQL 語法支持外連接。這裡是兩個例子：
-SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -- - -
SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- - - -
- 沒有辦法查詢當前資料庫之外的資料庫。 - 因為PostgreSQL要加載與資料庫相關的系統目錄（系統表），因此跨資料庫的查詢如何執行是不定的。 -
- -- 附加增值模塊 contrib/dblink 允許採用函數調用實現跨庫查詢。當然用戶也可以同時連接到不同的資料庫執行查詢然後在客戶端合併結果。 -
- -- 在函數中返回資料記錄集的功能是很容易使用的，詳情參見： - http://techdocs.postgresql.org/guides/SetReturningFunctions -
- -- 「複寫」只是一個術語，有好幾種複寫技術可用，每種都有優點和缺點： -
-- - 主/從式複寫方式是允許一個主伺服器接受讀/寫的申請，而多個從伺服器只能接受讀/SELECT查詢的申請， - 目前最流行且免費的主/從PostgreSQL複寫方案是 - Slony-I 。 -
-- 多個主伺服器的複寫方式允許將讀/寫的申請發送給多台的主機，這種方式由於需要在多台伺服器之間同步資料變動 - 可能會帶來較嚴重的性能損失，Pgcluster 是目前這種方案中最好的，並且還可以免費下載。 -
-- 也有一些商業需付費和基於硬體的資料複寫方案，支持上述各種複寫模型。 -
- - -- 最常見的原因是在創建表時對表名或是欄名使用了雙引號( ' ' )，當使用了雙引號後，表名或欄名（稱為標識符）存儲時是區分 -大小寫的， - 這意謂著你在查詢時表名或欄名也應使用雙引號，一些工具軟體，像 pgAdmin 會在發出創建表的指令時自動地在每個標識符上加雙引號。 - 因此，為了標識符的統一，你應該：
-Často kladené dotazy (FAQ) PostgreSQL -
-Poslední aktualizace: 29. října 2007 (aktualizováno pro PostgreSQL 8.3) -
-Současný správce: Bruce Momjian (bruce@momjian.us) -
-Přeložil: Pavel Stěhule (pavel.stehule@gmail.com) -
-Nejaktuálnější verzi tohoto dokumentu naleznete na adrese -http://www.postgresql.org/files/documentation/faqs/FAQ.html -
-Odpovědi na otázky vázané na konkrétní platformy naleznete na -adrese http://www.postgresql.org/docs/faq/. -
-Výslovnost PostgreSQL je Post-Gres-Q-L -, nebo zjednodušeně Postgres -. V řadě jazyků je slovo PostgreSQL obtížně vyslovitelný, proto se v hovoru často používá zjednodušená forma názvu. Pro ty, kteří by si rádi poslechli výslovnost, je k dispozici audiozáznam v MP3 formátu. -
-PostgreSQL je relační databáze s některými objektovými rysy, která má možnosti tradičních -komerčních databázových systémů s několika rozšířeními, které lze najít v DBMS -systémech příští generace. Používání PostgreSQL není omezené a veškeré zdrojové kódy jsou -volně dostupné. -
-Za vývojem PostgreSQL je mezinárodní skupina nezávislých vývojářů navzájem komunikujících -prostřednictvím internetu. Tento projekt není řízen žádnou obchodní organizací. Pokud se chcete -přidat k projektu, přečtěte si vývojářské FAQ na adrese http://www.postgresql.org/files/documentation/faqs/FAQ_DEV.html . -
-Pokud budete hledat organizaci řídící vývoj PostgreSQL, budete zklamáni. Nic takového -neexistuje. Existují pouze "core" a CVS skupiny uživatelů, ale ty existují více z administrátorských -důvodů než z organizačních. Projekt je směrován komunitou vývojářů a uživatelů, ke které se -kdokoliv může připojit. Jediné co potřebuje, je přihlásit se do elektronické konference. Více ve -vývojářském FAQ. -
-PostgreSQL je předmětem následujících autorských práv: -
-Dílčí Copyright (c) 1996-2009, PostgreSQL Global Development Group
-Dílčí Copyright (c) 1994-6, Regents of the University of California
-
Uděluje se oprávnění k užití, rozmnožování, provádění úprav a -rozšiřování tohoto softwaru a dokumentace k němu, pro jakékoli účely, -bez licenčního poplatku a bez písemné licenční smlouvy, za podmínky, -že na všech jeho kopiích je uvedeno oznámení o výše uvedených právech, -jakož i obsah tohoto a dvou následujících odstavců. -
-THE UNIVERSITY OF CALIFORNIA ("KALIFORNSKÁ UNIVERZITA") NENÍ V ŽÁDNÉM -PŘÍPADĚ ODPOVĚDNA ŽÁDNÉ TŘETÍ OSOBĚ ZA PŘÍMOU, NEPŘÍMOU, ZVLÁŠTNÍ, -NAHODILOU NEBO VÝSLEDNOU ŠKODU, VČETNĚ UŠLÉHO ZISKU, ZPŮSOBENOU UŽITÍM -TOHOTO SOFTWARU A DOKUMENTACE K NĚMU, A TO I V PŘÍPADĚ, ŽE THE -UNIVERSITY OF CALIFORNIA BYLA INFORMOVÁNA O MOŽNOSTI VZNIKU TAKOVÉ -ŠKODY. -
-THE UNIVERSITY OF CALIFORNIA ZEJMÉNA NEPOSKYTUJE JAKÉKOLI ZÁRUKY, A TO -NEJEN ZÁRUKY OBCHODOVATELNOSTI A VHODNOSTI TOHOTO VÝROBKU KE -SPECIFICKÝM ÚČELŮM. NÍŽE UVEDENÝ SOFTWARE JE POSKYTNUT "JAK STOJÍ A -LEŽÍ" A THE UNIVERSITY OF CALIFORNIA NENÍ POVINNA ZAJISTIT JEHO -ÚDRŽBU, PODPORU, AKTUALIZACI, VYLEPŠENÍ NEBO MODIFIKACI. -
-Výše uvedené je BSD licence, běžná licence otevřeného zdroje. Není zde -žádné omezení ohledně užití kódu zdroje. Jsme s tím spokojeni a nemáme -v úmyslu na této skutečnosti cokoli měnit. -
-Stručně řečeno, PostgreSQL běží na všech moderních unixových systémech. Seznam těch, u kterých proběhlo testování, naleznete v instalačních instrukcích. -
-PostreSQL také běží nativně na všech Microsof Windows systémech odvozených z Microsoft Windows NT jako jsou Windows 2000SP4, WindowsXP a Windows2003. Instalační balíček naleznete na adrese http://pgfoundry.org/projects/pginstaller. Na starších systémech s ještě MS-DOS jádrem lze spustit PostgreSQL s emulačním programem Cygwin. -
-Dále existuje port pro Novell Netware 6 port na adrese http://forge.novell.com, a pro OS/2 verze (eComStation) na adrese http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F . -
-Pomocí webového klienta z adresy http://www.postgresql.org/ftp/ nebo klienta ftp z adresy ftp://ftp.postgresql.org/pub/. -
-Nejnovější verzí PostgreSQL je verze 8.2.5 -
-V plánu je uvolňovat každoročně jednu velkou verzi a každých několik měsíců malé verze. -
-Nejčastější forma podpory uživatelům PostgreSQL komunitou je prostřednictvím e-mailů. Na našem webovém serveru naleznete odkaz na stránky,kde se můžete přihlásit do elektronické konference. Pro začátek jsou doporučené konference general nebo bugs. -
-Další cestou je IRC kanál #postgresql na Freenode (irc.freenode.net). K připojení použijte Unixový příkaz irc -x '#postgresql' "$USER" irc.freenode.net nebo jakékoholiv jiného IRC klienta. V této síti existuje ještě španělská (#postgresql-es) a francouzská (#postgresqlfr) verze. Další PostgreSQL kanál naleznete na EFNet. -
-Seznam společností poskytující komerční podporu naleznete na adrese http://techdocs.postgresql.org/companies.php. -
-Vyplňte formulář na adrese http://www.postgresql.org/support/submitbug. Na našem ftp serveru ftp://ftp.postgresql.org/pub/ si ověřte, že používáte aktuální verzi PostreSQL. -
-Chyby reportované prostřednictvím chybového formuláře nebo zasláním mailu do PostgreSQL konference obvykle generuje následující odezvu: -
-PostgreSQL podporuje rozšířenou podmnožinu SQL:2003. V našem TODO naleznete seznam známých chyb, chybějících vlastností, a plány do budoucna. -
-Odezva na požadavek na novou vlastnost PostgreSQL je obvykle: -
-PostgreSQL nepožívá systém pro sledování chyb, protože jsme zjistili, že je efektivnější přímo reagovat na maily a udržovat aktuální TODO. V praxi je snaha o co nejrychlejší řešení chyb, a chyby, které by se mohly projevit u mnoha uživatelů jsou opravovány velice rychle. Jediné místo, kde lze dohledat všechny změny, rozšíření a opravy v PostgreSQL je CVS log. Poznámky k verzi "Release notes" nezachycují všechny změny, k němž došlo. -
-PostgreSQL obsahuje vynikající dokumentaci zahrnující manuál, manuálové stránky a testovací příklady. Podívejte se do adresáře /doc. Manuál je přístupný online na http://www.postgresql.org/docs. -
-K dispozici jsou zdarma dvě online knihy na adresách http://www.postgresql.org/docs/books/awbook.html a http://www.commandprompt.com/ppbook/. Další literaturu lze zakoupit. Nejpopulárnější je od Kerryho Douglase. Seznam dostupné literatury je na http://techdocs.postgresql.org/techdocs/bookreviews.php. Ještě je kolekce technicky orientovaných článků tematicky spojených s PostgreSQL na adrese http://techdocs.postgresql.org/. -
-Řádkový klient psql má \d příkazy pro zobrazení informací o typech, operátorech, funkcích, agregačních funkcí, atd. Použijte \? pro zobrazení dostupných příkazů. -
-Další dokumentaci najdete na našem webu. -
-Podívejte se do výše uvedené dokumentace. Další online knihou je "Teach Yourself SQL in 21 Days, Second Edition" na adrese http://members.tripod.com/er4ebus/sql/index.htm. Mnoho našich uživatelů doporučuje knihu The Practical SQL Handbook, Bowman, Judith S., et al., Addison-Wesley. Další The Complete Reference SQL, Groff et al., McGraw-Hill. -
-Další online tutoriály jsou dostupné na adresách: -
-Prostudujte si Developer's FAQ. -
-Software můžeme porovnávat z několika různých pohledů: vlastnosti, výkon, spolehlivost, podpora a cena. -
- -PostgreSQL nabízí většinu funkcí funkcionality velkých komerčních DBMS systémů jako jsou: transakce, vnořené dotazy, spouště, referenční integrita a sofistikovaný systém zamykání. Poskytujeme určité funkce, které ostatní systémy běžně nepodporují. Např. uživatelem definované typy, dědičnost, pravidla (rules), a MVCC architekturu. -
-Výkon PostgreSQL je srovnatelný s ostatními komerčními nebo Open Source databázemi. V některých případech je rychlejší, jindy pomalejší. Náš výkon je obvykle +/-10% vůči ostatním databázím. -
-Uvědomujeme si, že databáze musí být stoprocentně spolehlivá, jinak je nepoužitelná. Snažíme se, aby každá verze byla dobře otestována a obsahovala minimum chyb. Každá verze je minimálně několik měsíců v beta testovacím režimu. Do produkčního režimu se dostane, až když nedochází k dalším změnám nebo opravám. Věříme, že jsem více než srovnatelní s ostatními databázemi v této oblasti. -
-Na našich internetových konferencích se setkává velká skupina vývojářů a uživatelů při řešení vyskytujících se problémů. -Naše internetové konference umožňují kontakt velké skupiny vývojářů a uživatelů. Nemůžeme garantovat opravu chyby, ale komerční DBMSs také vždy negarantují řešení problémů. Věříme ale, že díky přímému kontaktu na vývojáře, naši uživatelskou komunitu, manuálům, a dostupným zdrojovým kódům máme lepší podporu než ostatní DBMSs. Pro ty, kteří preferují komerční "per-incident" podporu, existuje společností, kteří ji nabízejí (FAQ sekce 1.7.) -
-PostgreSQL lze používat bezplatně (a to i pro komerční použití). Také můžete neomezeně používat náš kód ve svých produktech s výjimkami specifikovanými v naší licenci (přebíráme BSD licenci). -
-Počínaje verzí 8.0.[4+] podporuje PostgreSQL letní čas také pro USA. Podpora letního času (daylight saving time) pro Kanadu a Západní Austrálii je obsažena ve verzích 8.0.[10+] a 8.1.[6+] a všech následujících verzích. Starší verze používaly systémovou databázi časových zón obsahující, kromě jiného, informaci o tom, zda se pro danou časovou zónu rozlišuje mezi letním a zimním časem. -
-PostgreSQL se distribuuje pouze s rozhraním pro jazyk C a embedded C. Všechna další rozhraní představují nezávislé projekty, které je třeba stáhnout z internetu samostatně. Osamostatnění těchto projektů umožňuje nezávislost vývojových týmů a možnost vydávat nové verze bez ohledu na vydání nové verze PostgreSQL. -
-Některé programovací jazyky jako je např. PHP obsahují rozhraní pro PostgreSQL. Rozhraní pro jazyky jako je Perl, Tcl, Python a mnoho dalších jsou dostupné na adrese: http://gborg.postgresql.org v sekci Drivers/Interfaces. -
-Dobrým úvodem do problematiky databází v prostředí webových stránek může být web http://www.webreview.com. -
-PHP (http://www.php.net) je vynikajícím rozhraním pro tvorbu webů. -
-Pro složitější úlohy se často používá Perl a jeho BDB:Pg rozhraní s podporou CGI - CGI.pm nebo mod_perl(u). -
-K dispozici je řada grafických nástrojů podporujících PostgreSQL a to od komerčních nebo open source vývojářů. Podrobný seznam naleznete na adrese -http://www.postgresql.org/docs/techdocs.54. -
-Při spouštění configure nastavte parametr --prefix -
-Ve výchozí konfiguraci, PostgreSQL umožňuje pouze připojení z lokálního uživatele prostřednictvím Unix domain sockets nebo TCP/IP spojení. Bez modifikace listen_addresses v souboru postgresql.conf, a povolení adresy v souboru $PGDATA/pg_hba.conf se nelze připojit k PostgreSQL z ostatních stanic. Změna výše zmíněných parametrů vyžaduje restart databázového serveru. -
-Výkon systému můžete ovlivnit ve třech oblastech: -
-Určité parametry v souboru postgresql.conf mají vliv na výkon serveru. Detaily naleznete v příručce Administrátora v Server Run-time Environment/Run-time Configuration. Další komentáře naleznete v http://www.varlena.com/varlena/GeneralBits/Tidbits/annotated_conf_e.html a http://www.varlena.com/varlena/GeneralBits/Tidbits/perf.html. -
-Vliv hardware na výkon serveru je popsán v dokumentech http://candle.pha.pa.us/main/writings/pgsql/hw_performance/index.html a http://www.powerpostgresql.com/PerfList/. -
-Nastavením log_* proměnných v konfiguraci serveru si vynutíte logování dotazů a procesních statistik, které Vám mohou pomoci při ladění a optimalizaci výkonu. -
-Překročil jste výchozí limit, který je 100 současně připojených uživatelů. V konfiguraci serveru v postgresql.conf tuto hodnotu můžete zvětšit změnou hodnoty max_connection. Nezapomeňte restartovat server. -
-Způsob číslování je popsán v dokumentaci na http://www.postgresql.org/support/versioning. Instrukce k provedení migrace na vyšší verzi jsou taktéž v dokumentaci na adrese http://www.postgresql.org/docs/current/static/install-upgrading.html. -
-Jelikož PC jsou většinou kompatibilní, lidé mají tendence věřit, že všechna PC jsou stejně kvalitní. Což není pravda. Paměti ECC, SCSI a kvalitní základní desky jsou mnohem spolehlivější a výkonnější než lacinější hardware. PostgreSQL poběží na většině hardwaru, nicméně pokud je pro Vás spolehlivost a výkon systému důležitá, je dobré věnovat čas nalezení vhodné hardwarové konfigurace. Na našich elektronických konferencích můžete diskutovat o vhodných konfiguracích a značkách. -
-Pokud potřebujete pouze několik řádků a pokud víte kolik, použijte -SELECT LIMIT. Pokud bude možné použít index shodující se s ORDER BY, -je možné, že se nebude provádět celý dotaz. Pokud neznáte počet záznamů, -použijte kurzor a příkaz FETCH. -
-Pro výběr náhodného řádku použijte příkaz ve tvaru: -
--SELECT col -FROM tab -ORDER BY random() -LIMIT 1; --
V psql příkazem \dt získáte seznam tabulek. Úplný seznam příkazů psql získáte příkazem \?. Alternativně si můžete prostudovat zdrojový kód psql - soubor pgsql/src/bin/psql/describe.c, který obsahuje SQL příkazy, které jsou generovány pro získání výstupu psql "backslash" příkazů. Také můžete nastartovat psql s parametrem -E, který způsobí zobrazení všech SQL příkazů, které se odesílají na server. PostgreSQL také podporuje SQL standard INFORMAČNÍ SCHÉMATA (standardní systémové tabulky). Klasickým dotazem do systémových tabulek získáte požadované informace o struktuře databáze. -
-Systémové tabulky PostgreSQL (mimo rámec SQL standardů) používají prefix pg_. Pro zjištění struktury databáze je můžete použít také, i když preferovány jsou dotazy do informačního schématu. -
-Seznam všech databází získáte příkazem psql -l -
-Další inspiraci najdete v souboru pgsql/src/tutorial/syscat.source. Obsahuje ilustrační SELECTy potřebné k získání informací z systémových tabulek databáze. -
-Ve verzích 8.0 a pozdějších jednoduše: -
--ALTER TABLE ALTER COLUMN TYPE -
V starších verzích: -
--BEGIN; -ALTER TABLE tab ADD COLUMN new_col new_data_type; -UPDATE tab SET new_col = CAST(old_col AS new_data_type); -ALTER TABLE tab DROP COLUMN old_col; -COMMIT; -
Po změně spusťte příkaz VACUUM FULL, aby došlo k uvolnění diskového prostoru použitého v tu chvíli již neplatnými záznamy. -
-PostgreSQL má tato omezení: -
-| Maximální velikost databáze: | neomezena (existují 32TB db) - |
| Maximální velikost tabulky: | 32 TB - |
| Maximální velikost řádky: | 480GB - |
| Maximální velikost položky | 1 GB - |
| Maximální počet řádků v tabulce: | neomezeno - |
| Maximální počet sloupců v tabulce: | 250-1600 podle typů - |
| Maximální počet indexů na tabulce: | neomezeno - |
Ve skutečnosti nic není neomezeno, limitem bývá vždy dostupná disková -paměť nebo velikost operační paměti. Pokud máte některou z těchto -hodnot neobvykle velkou, může dojít ke snížení výkonu. -
-Maximální velikost tabulky je 32 TB a nevyžaduje podporu velkých -souborů operačním systémem. Velké tabulky se ukládají do několika 1 GB -souborů takže limity souborového systému nejsou podstatné. -
-Maximální velikost tabulky a maximální počet sloupců můžeme -zečtyřnásobit nastavením velikosti bloku na 32K. -
-Indexy jsou povolené pouze na sloupcích jejichž délka je menší než 2000 znaků. Pokud tuto délku překročíme a index potřebujeme pro zajištění jednoznačnosti, je vhodnější použít funkcionální index nad MD5 funkcí nebo fulltextový index. -
-PostgreSQL vyžaduje až pětinásobek diskového prostoru k uložení dat z -textového souboru. -
-Například, uvažujme soubor se 100 tisíci řádky obsahující na každé -řádce celé číslo a textový popis. Text je v průměrně dvacet bytů -dlouhý. Textový soubor bude 2.8 MB dlouhý. Velikost databáze -obsahující odpovídající data bude zhruba 5.2 MB. -
-- 24 bytů: hlavička řádku (přibližně) - 24 bytů: jedna celočíselná položka a jedna textová - + 4 byty: ukazatel na stránku k entici - ------------------------------------------------------ - 52 bytů na řádek -
Velikost datové stránky PostgreSQL je 8192 bytů (8KB) -
-- 8192 bytů na stránce ----------------------- = 158 řádek na stránku - 52 bytů za řádek - -100000 řádek ------------------------ = 633 stránek (zaokrouhleno nahoru) - 158 řádek na stránce - -633 datových stránek * 8192 bytů na každou stránku = 5,185,536 bytů (5.2 MB) -
Indexy nemají tak velkou režii, ale mohou být také velké, protože -obsahují indexovaná data. -
-Hodnoty NULL jsou uloženy v bitmapách, takže zabírají jen velmi málo -diskového prostoru. -
-Každý dotaz nemusí nutně použít existující indexy. Index se použije -tehdy, když je tabulka větší než určitá minimální velikost, a dotaz -vybírá pouze procentuálně malou část řádků tabulky. To proto, že -náhodný přístup k disku daný čtením indexu může být pomalejší než -lineární čtení tabulky nebo sekvenční čtení. -
-PostgreSQL rozhoduje o použití indexů na základě statistiky přístupů k -tabulce. Tyto statistiky se shromažďují příkazy VACUUM ANALYZE nebo -ANALYZE. Díky statistikám má optimizer informaci o počtu řádek v -tabulce a může lépe rozhodnout o použití indexů. Statistiky se uplatní -při určení optimálního pořadí a metody spojení tabulek. Statistiky by -se měli aktualizovat opakovaně, tak jak se mění obsah tabulek. -
-Indexy nejsou obyčejně použity pro setřídění nebo spojení tabulek. -Sekvenční zpracování následované explicitním tříděním je obyčejně -rychlejší než použití indexu na velké tabulce. -
-Jinak je tomu v případě použití LIMIT a ORDER BY, při kterém se -většinou index použije, jelikož je výsledkem pouze malá část tabulky. -
-Pokud si myslíte, že optimizer mylně zvolil sekvenční prohledávání -tabulky, použijte příkaz SET enable_seqscan TO 'off' a zkuste zda je -prohledávání s indexem rychlejší. -
-Při vyhledávání na základě vzoru jako je např. operátor LIKE nebo ~ se -indexy použijí pouze za určitých skutečností: -
-Podívejte se do nápovědy k příkazu EXPLAIN. -
-Vyhledávání prostřednictvím regulárních vzorů zajišťuje operátor ~, který je case-sensitive. Jeho case-insensitive varianta je operátor ~*. Case-insensitive variací operátoru LIKE je operátor ILIKE. -
-Case-insensitive vyhledání se řeší: -
--SELECT * -FROM tab -WHERE lower(col) = 'abc'; -
Tento dotaz nepoužije standardní index. Musíte použít tzv. funkcionální index: -
--CREATE INDEX tabindex ON tab (lower(col)); -
Pokud index vytvoříme jako unikátní, tak můžeme ukládat řetězce obsahující malá i velká písmena, ale nikoliv řetězce, které se od sebe odlišují jen v malých a velkých písmenech. K zajištění zápisu řetězce obsahující pouze malá nebo pouze velká písmena použijte CHECK kontroly nebo triggery. -
-Pokud chcete testovat hodnotu NULL použijte operátor IS: -
-- SELECT * - FROM tab - WHERE col IS NULL; -
K spojení řetězců, které mohou obsahovat hodnotu NULL, používejte funkci COALESCE(), např.: -
-- SELECT COALESCE(col1, '') || COALESCE(col2, '') - FROM tab -
Pokud chcete třídit podle hodnoty NULL, použijte výraz IS NULL nebo IS NOT NULL v klauzuli ORDER. Hodnota pravda má přednost před hodnotou false a tedy pokud použijete: -
-- SELECT * - FROM tab - ORDER BY (col IS NOT NULL) -
tak záznamy s NULL budou na začátku setříděných dat. -
-| Typ | Interní název | Poznámky - |
| VARCHAR(n) | varchar | n určuje maximální délku - |
| CHAR(n) | bpchar | řetězec je do dané délky rozšířen mezerami - |
| TEXT | text | bez omezení délky - |
| BYTEA | bytea | pole bytů nespecifikované délky - |
| "char" | char | jeden znak - |
Na interní názvy můžete narazit v systémovém katalogu nebo v některých chybových hlášeních. -
-Čtyři první typy jsou tzv. varlena typy (první čtyři byty na disku jsou obsahují délku, ostatní obsahují vlastní data). Skutečně obsazený prostor je tedy o něco málo větší než deklarovaná velikost. Na druhou stranu, delší řetězce jsou komprimovány, takže obsazený prostor na disku může být menší než se čeká. -
-VARCHAR(n) je vhodný pro ukládání různě dlouhých řetězců u kterých známe délkové omezení, TEXT pro řetězce bez omezení délky (maximum je jeden gigabyte). -
-CHAR(n) se používá pro uložení stejně dlouhých řetězců. CHAR(n) doplní mezerami na specifikovanou délku, VARCHAR(n) hodnoty se ukládají tak jak jsou. BYTEA je pro ukládání binárních dat - non ASCII hodnot. Všechny zmíněné typy mají podobné výkonové charakteristiky. -
-V PostgreSQL můžete použít datový typ SERIAL. Jeho použitím se automaticky vytvoří sekvence. -Například: -
--CREATE TABLE person ( - id SERIAL, - name TEXT -); -
je automaticky transformováno na: -
-
-CREATE SEQUENCE person_id_seq;
-CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
-);
-Podrobnější informace najdete v manuálu v popisu příkazu create_sequence. -
-Nejjednodušším způsob, jak získat vygenerovanou hodnotu typu SERIAL, je využít klauzuli RETURNING. Pro tabulku z 4.11.1 vypadá takto: -
-
-INSERT INTO person (name) VALUES ('Blaise Pascal') RETURNING id;
-Také můžete použít funkci nextvall() a její výsledek použít v příkazu INSERT, nebo zavolat currval() po provedení příkazu INSERT. -
-Ne, currval vrací vždy hodnotu, která byla vygenerována pro vás. -
-Poté co sekvence vygeneruje nové číslo, tak se nedochází k zamčení sekvence a nečeká se na úspěšné nebo neúspěšné dokončení transakce. Odvoláním transakce, která si vyžádala čísla sekvence se tato čísla nenávratně ztratí. -
-V případě, že tabulku nezaložíme s atributem WITHOUT OIDS, tak má každý řádek unikátní identifikační číslo OID. Toto číslo je 4 bajtové celé číslo, které je jedinečné v celé instalaci. Přeteče po 4 miliardách řádků. PostgreSQL používá OIDs jako interní linky v interních systémových tabulkách. -
-K získání unikátního čísla v nesystémových tabulkách je vhodnější použití typu SERIAL než OID, jelikož sekvence SERIAL se používá pouze pro jednu tabulku a je tudíž méně náchylná na přetečení. Pokud byste se toho obávali, použijte typ SERIAL8. -
-CTID se používá k identifikaci konkrétního fyzického řádku. CTID se mění pokud je řádek modifikován nebo znovu načten. Používají ho indexy jako adresaci fyzických řádků. -
-Pravděpodobně jste vyčerpal dostupnou virtuální paměť, nebo tvůj kernel -má příliš nízké limity u určitých zdrojů. Před startem PostgreSQL vyzkoušejte: -
--ulimit -d 262144 -limit datasize 256m -
Možná, že se projde pouze jeden příkaz - záleží to na vašem shellu. -Měl by zvednout limity datových segmentů vašich procesů na dostatečně velkou -hodnotu a snad umožnit dokončení dotazu. Změna limitů se bude aplikovat -pouze na aktuální proces a na všechny nově vytvořené procesy. Jestliže máte -problém s SQL klientem, protože vám server vrátil příliš dat, zkuste to -před startem klienta. -
-V psql napište: -
--SELECT version(); --
Použijte CURRENT_TIMESTAMP: -
--CREATE TABLE test (x int, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); --
PostgreSQL podporuje standardní SQL syntaxi pro vnější spojení. Zde jsou -dva příklady: -
--SELECT * -FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -
nebo -
--SELECT * -FROM t1 LEFT OUTER JOIN t2 USING (col); -
Tyto identické dotazy spojí sloupec t1.col k sloupci t2.col, a ještě vrátí všechny nespárované řádky t2 (ty, které nedohledá v t2). RIGHT JOIN by připojil všechny nespárované řádky z t2. FULL JOIN vrátí všechny spárované řádky i všechny zbývající řádky z obou tabulek. Klíčové slovo OUTER je volitelné. Běžná operace JOIN se také označuje jako vnitřní spojení. -
-Neexistuje žádný způsob, jak se v dotazu odkazovat na tabulky z jiné než aktuální databáze. A to protože má systémové tabulky uložené nezávisle v každé databázi a není tak úplně zřejmé, jak by se dotaz provedený napříč databázemi měl chovat. -
-Jeden z doplňků dblink umožňuje dotaz nad několika tabulkami pomocí funkcí. Druhý způsob je simultální připojení klienta ke všem relevantním databázím a sloučení výsledku na straně klienta. -
-Jde to jednoduše pomocí set-returning funkce. Více na -http://www.postgresql.org/docs/techdocs.17. -
-Nechtěným vedlejším efektem kešování SQL dotazů v PL/pgSQL funkci je problém s neplatnými odkazy na dočasné tabulky, které byly od prvního spuštění funkce zrušeny a znovu vytvořeny před dalším spuštěním PL/pgSQL funkce. Řešením je použít příkaz EXECUTE a to proto, že prováděcí plán SQL příkazu spouštěného příkazem EXECUTE se vytváří pokaždé znovu (neukládá se do cache). -
-Tento problém by se neměl vyskytovat u PostgreSQL verze 8.3 a vyšších verzích. -
-Replikaci databáze umožňuje několik technoligií. Každá má určité výhody a nevýhody. -
-Master/Slave replikaci podporuje jeden hlavní server, který přijímá požadavky na zápis a čtení, a několik podřízených serverů, které umožňují pouze čtení (SELECT). Nejrozšířenějším volně dostupným řešením tohoto typu je Slony-I. -
-Replikace typu Multi-master podporuje existenci několika serverů s povoleným zápisem na více replikovaných serverech. Toto řešení zvyšuje zátěž serverů, protože je nutná synchronizace serverů. Nejrozšířenějším volně dostupným řešením je PGCluster. -
-Ještě existuje několik komerčních a hardware řešení replikací podporujících různé modely replikace. -
-Nejčastějším důvodem nerozpoznání názvu objektu bylo použití vložení názvu sloupce nebo tabulky mezi uvozovky při zakládání tabulky. Pokud se název zapíše mezi uvozovky, pak je case sensitive, a v důsledku toho je nutné názvy těchto sloupců nebo tabulek v SQL příkazech také vkládat mezi uvozovky (pokud obsahují velká písmena). Některé programy, jako je například pgAdmin, automaticky používají uvozovky. Takže pokud chcete, aby systém identifikoval identifikátor, musíte: -
-تاريخ آخرين اصلاح اين فايل: 28 -شهریور 1383 هجری شمسی
-نگهدارنده اصلي فايل (زبان -انگليسي)در حال حاضر : Bruce Momjian -pgman@candle.pha.pa.us
-نگهدارنده فايل به زبان فارسي:
-
-m.taghizadeh@imenafzar.net محمود
-تقيزاده مهرجردی
آخرين نسخه اين فايل را -ميتوانيد از اين آدرس بگيريد http://www.PostgreSQL.org/docs/faqs/FAQ.html
-سوالاتي كه در مورد يك -سکوی(پلتفرم) خاص است در اين آدرس جواب داده شده اند - http://www.PostgreSQL.org/docs/index.html
-1.1) PostgreSQL
-چيست و چگونه بايد آن را تلفظ كرد؟
1.2)
-قانون كپي رايت (حقوق معنوي) در مورد PostgreSQL
- به چه صورت است؟
1.3)
-PostgreSQL روي چه نوع
-يونيكسهايي اجرا ميشود؟
1.4)
-روي چه محيطهاي غير يونيكسي ميتوان آن
-را اجرا كرد؟
1.5) PostgreSQL
-را از كجا ميتوانم بگيرم؟
1.6)
-از كجا خدمات پشتيباني بگيرم؟
1.7)
-آخرين نسخه اعلام شده چيست؟
1.8)
-چه مستندات و راهنمائيهايي وجود دارند؟
1.9)
-چگونه ميتوانم ازاشكالات شناخته شده و يا امكاناتي كه در اين
-پايگاه داده وجود ندارد مطلع شوم؟
1.10)
-چگونه ميتوانم زبان
-SQL را ياد بگيرم؟
1.11)
-آيا PostgreSQL
-مشكل Y2K
-دارد يا خير؟
1.12)
-چگونه ميتوانم به تيم برنامه نويس
-PostgreSQL
-ملحق شوم؟
1.13)
-چگونه ميتوانم يك اشكال را به گروه برنامه نويس اعلام كنم؟
1.14)
- وضعيت
-PostgreSQL در
-مقايسه با ساير DBMSها به چه
-صورت است؟
1.15)
-من چگونه ميتوانم از نظر مالي به PostgreSQL
-كمك كنم؟
-
2.1)
-آيا هيچ درايور ODBC
-براي PostgreSQL
-وجود دارد؟
2.2)
-چه ابزارهايي براي استفاده از PostgreSQL
-با صفحات وب وجود دارد؟
2.3)
-آيا PostgreSQL يك واسط كاربري گرافيكي
-دارد؟
2.4)
-با چه زبانهاي برنامهنويسي ميتوان با PostgreSQL
-ارتباط برقرار كرد؟
-
3.1)
-چگونه ميتوانم PostgreSQL را در شاخهاي
-غير از /usr/local/pgsql/ نصب كنم؟
3.2)
-چرا موقعي كه من برنامه postmaster را
-اجرا مي كنم پيام Bad system call و يا core dump
-ميگيرم؟
3.3)
-چرا موقعي كه من سعي ميكنم برنامه postmaster
-را اجرا كنم خطاي IpcMemoryCreate ميگيرم؟
3.4)
-چرا موقعي كه من سعي ميكنم برنامه postmaster
-را اجرا كنم خطاي IpcSemaphoreCreate
-ميگيرم؟
3.5)
-چگونه ميتوانم اتصالات ساير ماشينها را كنترل كنم؟
3.6)
-براي كارايي بالاتر و بهتر پايگاه داده من چه تنظيماتي را بايد
-انجام دهم؟
3.7)
-چه امكاناتي براي پيدا كردن اشكال وجود دارد؟
3.8)
-چرا موقعي كه من ميخواهم به پايگاه داده وصل شوم پيام
-"Sorry, too many clients"
-ميگيرم؟
3.9)
-در شاخه pgsql_tmp چه چيزي قرار دارد؟
3.10)
-چرا براي به روز كردن نسخه پايگاه داده من بايد كل داده ها را
-dump و مجدداً restore كنم؟
3.11)
-از چه سخت افزاري بايد استفاده كنم؟
-
4.1) تفاوت بين binary cursors و
-Normal cursors چيست؟
4.2)
-من چگونه ميتوانم فقط روي چند رديف اول يا يك رديف تصادفي درخواست
-SELECT بزنم؟
4.3)
-من چگونه ميتوانم ليستي از جداول يا ساير چيزهايي كه در
-psql وجود دارد را ببينم؟
4.4)
-چگونه يك ستون جدول را حذف ميكنيد؟ چگونه نوع داده آن را عوض
-كنيم؟
4.5)
-حداكثر اندازه يك رديف، جدول و خود پايگاه داده چقدر است؟
4.6)
-چقدر فضاي ديسك سخت براي ذخيره كردن دادههاي يك فايل متني مورد
-نياز است؟
4.7)
-چگونه ميتوانم بفهمم كه چه كاربران، پايگاه داده، نمايه و
-جداولي در سيستم تعريف شده است؟
4.8)
-چرا درخواستهاي من كند اجرا ميشوند يا چرا از نمايه ها استفاده
-نميكنند؟
4.9)
-چگونه ميتوانم نحوه بررسي درخواست را توسط بهينهساز درخواستها
-مشاهده كنم؟
4.10)
-نمايه R-tree چيست؟
4.11)
-بهينه ساز تكويني درخواست چيست؟ (Genetic Query Optimizer)
4.12)
-چگونه از عبارات منظم براي جستجو استفاده كنم؟ چگونه جستجويي انجام
-دهم كه حساس به متن نباشد؟ چگونه براي يك جستجوي غير حساس به متن از نمايه استفاده
-كنم؟
4.13)
-چگونه ميتوانم در يك درخواست تشخيص دهم كه يك فيلد NULL
-است؟
4.14)
-تفاوت بين گونههاي مختلف character چيست؟
4.15.1)
-چگونه ميتوانم يك فيلد سريال يا افزايشي ايجاد كنم؟
4.15.2)
-چگونه ميتوانم مقدار يك درج سريالي را بدانم؟
4.15.3) آیا توابع ()nextval
-و ()currval منجر به ایجاد شرایط race
-برای سایر کاربران می شوند؟
4.15.4)
-چرا اعداد سریالی مربوط به تراکنشهای abort
-شده مجدداً استفاده نمی شود؟ چرا بین اعداد سریالی یک فاصله خالی ایجاد می شود؟
4.16) OID و TID چه
-هستند؟
4.17)
-معني بعضي از ترمها و كلماتي كه در PostgreSQL
-استفاده ميشود چيست؟
4.18)
-چرا من خطاي "ERROR: Memory exhausted in AllocSetAlloc"
-ميگيرم؟
4.19)
-از كجا تشخيص دهم كه ويرايش يا نسخه PostgreSQLيي
-كه من استفاده ميكنم چيست؟
4.20) چرا در حین اجرای عملیات روی
-large-objectها خطای "invalid large obj descriptor"به
-وجود می آید؟
4.21)
-چگونه يك ستون ايجاد كنم كه مقدار زمان جاري را به عنوان مقدار
-پيشفرض داشته باشد؟
4.22)
-چرا زير درخواستهايي كه از IN استفاده
-ميكنند كند هستند؟
4.23)
-چگونه ميتوانم يك الحاق خارجي (outer join)
-انجام دهم؟
4.24)
-چگونه ميتوان درخواستهايي از چند پايگاه داده توليد كرد؟
4.25)
-چگونه خروجي يك تابع ميتواند چند رديف يا ستون باشد؟
4.26)
-در توابع PL/PgSQL چرا نميتوان با اطمينان
-جداول موقت را ايجاد يا حذف كرد؟
4.27)
-چه گزينههايي براي تكرار (replication)
-وجود دارد؟
4.28)
-چه گزينههايي براي رمزنگاري وجود دارد؟
-
5.1)
-من يك تابع نوشتهام. چگونه آن را در psql
-اجرا كنم؟ چرا با اجراي آن core dump ميگيرم؟
5.2)
-چگونه ميتوانم در توليد نوعها و توابع جديد و جالب براي
-PostgreSQL همكاري و مشاركت داشته باشم.
5.3)
-چگونه ميتوانم يك تابع به زبان C بنويسم
-كه خروجي آن يك tuple (چند
-تايي) باشد؟
5.4)
-من يك فايل منبع را عوض كرده ام چرا در عمليات كامپيل مجدد آن
-تغيير ديده نميشود؟
-
PostgreSQL به صورت -Post-Gres-Q-L تلفظ ميشود. يك فايل صوتي در آدرس - -http://www.postfresql.org/postgresql.mp3 براي كساني كه مايلند تلفظ -صحيح را بشنوند وجود دارد.
-PostgreSQL از روي سيستم مديريت پايگاه -داده POSTGRES توسعه داده شده است (هنوز هم بعضي مواقع -براي سادگي به آن Postgres گفته ميشود) كه يك نمونه -تحقيقاتي از پايگاه دادههاي نسل بعد است. PostgreSQL -همان الگوي داده قوي و انواع داده را حفظ كرده است ولي زبان -PostQuel را با يك زيرمجموعه پيشرفته از -SQL جايگزين كرده است. PostgreSQL -متن باز بوده و متن كامل آن در دسترس است.
-PostgreSQL توسط يك -تيم برنامهنويس كه همگي در گروه پست الكترونيك برنامهنويسان -PostgreSQL عضو هستند، انجام ميشود. هماهنگ كننده -اصلي در حال حاضر Marc G. Fournier به آدرس - -scrappy@PostgreSQL.org ميباشد. (براي ديدن نحوه ملحق شدن به اين -تيم قسمت 1.6 -را ببينيد). اين تيم در حاضر مسئوليت تمام مسائل مربوط به برنامهنويسي -PostgreSQL را بر عهده دارد. اين يك پروژه گروهي است و -تحت كنترل هيچ شركتي نيست. براي اطلاعات بيشتر در مورد اين تيم به آدرس - -http://www.PostgreSQL.org/docs/faqs/FAQ_DEV.html -مراجعه كنيد.
-اولين نسخه PostgreSQL -توسط Andrew Yu and Jolly Chen به وجود آمد. افراد بسياري در توسعه و رفع اشكال و -انتقال آن شركت كردهاند. متن اصلي Postgres كه -PostgreSQL از روي آن نوشته شده است، توسط تعداد زيادي -دانشجوي كارشناسي ارشدو دانشجوي كارشناسي و تيم برنامهنويسي كه تحت نظر پروفسور -Michael Stonebrake در دانشگاه بركلي،كاليفرنيا كار ميكردهاند نوشته شده است.
-نام اصلي نرم افزار در دانشگاه بركلي -Postgres بود. در سال 1995 بعد از اضافه شدن -SQL نام آن به Postgres95 -تغيير داده شد. در سال 1996 نام آن به -PostgreSQL تغيير داده شد.
-PostgreSQL تحت قانون -كپي رايت زير قرار دارد:
-PostgreSQL Data Base Management System
-Portions copyright (c) 1996-2004, PostgreSQL -Global Development Group Portions Copyright (c) 1994-6 Regents of the University -of California
-Permission to use, copy, modify, and distribute -this software and its documentation for any purpose, without fee, and without a -written agreement is hereby granted, provided that the above copyright notice -and this paragraph and the following two paragraphs appear in all copies.
-IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA -BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR -CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS -SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-THE UNIVERSITY OF CALIFORNIA SPECIFICALLY -DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED -HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO -OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR -MODIFICATIONS.
-قانون بالا ليسانس BSD -كه يك ليسانس كلاسيك براي متنهاي باز است ميباشد. هيچ محدوديتي در مورد نحوه -استفاده از متن در آن ديده نميشود. ما آن را دوست داريم و هيچ قصدي براي تغيير آن -نداريم.
-در حالت كلي PostgreSQL -روي هر پلتفرم (سكوي) سازگار با يونيكس اجرا ميشود. ليست پلتفرمهايي كه تاكنون -PostgreSQL روي آنها نصب و تست شده است درقسمت -دستورالعملهاي نصب آمده است.
-Client
-ميتوان psql, -كتابخانه libpq و ساير واسطها و برنامههاي كاربردي را -طوري كامپيل كرد كه روي محيطهاي ويندوز نيز اجرا شوند. در اين حالت -Client روي ويندوز اجرا ميشود و از طربق شبكه و پروتكل -TCP/IP با يك سرور كه روي يك پلتفرم لينوكس در حال -اجراست ارتباط برقرار ميكند.يك فايل win32.mak همراه با -كدهاي PostgreSQL وجود دارد كه براي كامپيل كردن -كتابخانه libpq و برنامه psql -ميباشد. PostgreSQL همچنين -امكان ارتباط به صورت ODBC را نيز دارد.
-Server
-با استفاده از -Cygwin و كتابخانه Cygnus -ميتوان پايگاه داده را روي ويندوز NT و يا -Win2K اجرا كرد.براي ديدن اطلاعات بيشتر فايل - pgsql/doc/FAQ_MSWIN -را كه بهمراه توزبعهاي PostgreSQL آمده است -ببينيد و يا اينكه به اين صفحه -http://www.PostgreSQL.org/docs/faqs/text/FAQ_MSWIN -مراجعه كنيد.
-در حال حاضر يك عمليات انتقال -PostgreSQL به روي سكوهاي Win NT/2000/XP در -جريان است. براي ديدن وضعيت اين پروژه به سايتهاي -http://momjian.postgresql.org/main/writings/pgsql/win32.htm و -http://techdocs.postgresql.org/guides/Windows -مراجعه كنيد.
-همچنين يك عمليات انتقال بر روي -Novell Netware 6 نيز در حال انجام است كه در سايت http://forge.novell.com ميتوانيد اطلاعات -بيشتر را ببينيد.
-PostgreSQL را از -سايت اصلي آن ftp://ftp.PostgreSQL.org/pub ميتوانيد -بگيريد. در صفحه اصلي سايت ليست ساير آدرسهايي كه ميتوانيد -PostgreSQL را از آنها بگيريد آمده است.
-گروه پستي اصلي pgsql-general@PostgreSQL.org -ميباشد. اين گروه براي بحث در مورد موضوعات مختلف در زمينه -PostgreSQL است. براي عضو شدن در اين گروه پستي يك نامه الكترونيكي به آدرس -گروه با محتوياتی كه در ادامه آمده است ارسال كنيد. در قسمت -Subject چيزي ننويسيد.
-subscribe - end --
آدرس گروه: -pgsql-general-request@PostgreSQL.org
-همچنين يك گروه پستي هم به صورت ارسال چكيده -پيامها وجود دارد. براي عضو شدن در اين گروه يك نامه با محتويات زير به این آدرس -ارسال كنيد. -pgsql-general-digest-request@PostgreSQL.org -
-subscribe - end -
در اين گروه هر موقع حجم نامهها به 30 كيلوبايت -رسيد براي تمام اعضاء ارسال ميشود.
-گروه پستي بررسي اِشكالات هم وجود دارد. براي عضو -شدن در اين گروه يك نامه با محتويات زير به - -pgsql-bugs-request@PostgreSQL.org -ارسال كنيد.
-subscribe - end -
گروه پستي مخصوص توسعه دهندگان (برنامهنويسان) -نيز وجوددارد. براي عضويت در اين گروه يك نامه به آدرس زير با محتويات مشخص شده -ارسال كنيد. -pgsql-hackers-request@PostgreSQL.org -
-subscribe - end --
گروههاي پستي ديگري نيز در زمينه -PostgreSQL وجود دارد كه ميتوانيد در سايت http://www.postgresql.org ببينيد.
-همچنين يك كانال IRC
-روي Freenode و EFNet بنام
-PostgreSQL#
-وجود دارد. شما ميتوانيد از فرمان يونيكسي
-irc -c '#PostgreSQL' "$USER" irc.phoenix.net.
-يا
-irc -c '#PostgreSQL' "$USER" irc.freenode.net
-استفاده كنيد.
ليست شركتهايي كه از طريق آنها ميتوانيد خدمات
-پشتيباني تجاري در زمينه PostgreSQL دريافت كنيد در اين
-آدرس
-http://techdocs.postgresql.org/companies.php
-موجود است.
آخرين نسخه PostgreSQL - كه وجود دارد 7.4.3 است.
-هدف ما آن است كه هر 6 ماه تا 8 ماه يك نسخه جديد -ارائه شود.
-چندين كتابچه و صفحات راهنما و مثالهاي كوچك -همراه با متن اصلي PostgreSQL در شاخه -doc وجود دارد. براي ديدن صفحات راهنما ميتوانيد به -سايت http://www.PostgreSQL.org/docs - نيز مراجعه نماييد.
-دو كتاب در زمينه PostgreSQL - در آدرسهاي -http://www.PostgreSQL.org/docs/awbook.htm -و http://www.commandprompt.com/ppbook -وجود دارد. ليستي از كتابهايي كه قابل خريد است در آدرس -http://techdocs.PostgreSQL.org/techdocs/bookreviews.php -وجود دارد. همچنين ليستي از مقالات فني در مورد -PostgreSQL در آدرس http://techdocs.PostgreSQL.org -وجود دارد.
-برنامه psql يك دستور -d\ دارد كه اطلاعاتي در مورد انواع دادههاي قابل تعريف -و عملگرها و توابع و ... به ما نشان ميدهد. در سايت اصلي ما اطلاعات بيشتري را -ميتوانيد پيدا كنيد.
-PostgreSQL يك زير -مجموعه پيشرفته از SQL-92 را پشتيباني ميكند. در ليست - TODO اِشكالات -شناخته شده يا امكاناتي كه وجود ندارد و يا برنامههاي آينده آمده است.
-كتاب PostgreSQL در -آدرس SQL -http://www.PostgreSQL.org/docs/awbook.html -را آموزش ميدهد. همچنين يك كتاب در آدرس http://www.commandprompt.com/ppbook -وجود دارد. يك راهنماي خيلي خوب هم در سايتهاي -http://www.intermedia.net/support/sql/sqltut.shtm -و -http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM -و http://sqlcourse.com در مورد -SQL وجود دارد.
-كتاب ديگري كه ميتوان براي يادگيري -SQL از آن استفاده كرد كتاب "SQL -را در 21 روز ياد بگيريد، ويرايش دوم" در سايت -http://members.tripod.com/er4ebus/sql/index.htm -ميباشد.
-تعداد زيادي از كاربران كتاب -The Practical SQL را ترجيح ميدهند. كتاب ديگر The -Complete Refrence SQL انتشارات McGraw-Hill -ميباشد.
-خير،PostgreSQL با -تاريخهاي قبل و بعد از 2000 مشكلي ندارد.
-ابتدا،آخرين سورس را دونلود كرده و مستندات -مربوط به برنامهنويسي PostgreSQL را در سايت مطالعه -كنيد. سپس به گروههاي پستي pgsql-patches -و pgsql-hackers - عضو شويد. در مرحله آخر وصلههاي با كيفيت بالا را به -pgsql-patches ارسال كنيد.
-تعداد زيادي از برنامهنويسان وجود دارند كه -امتياز انجام تغييرات در cvs را دارند. هر كدام از آنها -تعداد زيادي وصله با كيفيت بالا به گروه ارسال كردهاند كه اعتماد گردانندگان -PostgreSQL را به دست آوردهاند.
-لطفاً صفحه مربوط به اِشكالات -PostgreSQL را در سايت -http://www.PostgreSQL.org/bugs/bugs.php -مشاهده كنيد. در اين سايت نحوه گزارش و ارسال يك -اشكال توضيح داده شده است.
-همچنين براي ديدن -نسخههاي جديدتر PostgreSQL و يا وجود يك وصله جديد از -سايت ftp://ftp.PostgreSQL.org/pub بازديد -كنيد.
-راههاي مختلفي براي اندازهگيري و مقايسه -نرمافزارها وجود دارد كه عبارتند از امكانات، كارايي، قابليت اعتماد، پشتيباني و -قيمت
-
- كارايي PostgreSQL در حد بقيه سيستمهاي تجاري و - متن باز است. در بعضي موارد سريعتر و در بعضي موارد از آنها كندتر است. در - مقايسه با MySQL براي كاربران بيشتر و درخواستهاي - پيچيده و بار زياد خواندن/نوشتن سريعتر است. در درخواستهاي ساده - SELECT از MySQL كندتر است. البته - MySQL خيلي از امكانات - PostgreSQL كه در بالا به آن اشاره شد را ندارد. هدف اصلي ما امكانات و - قابليت اعتماد بالاست در ضمن آنكه تلاش ميكنيم تا كارايي آن نيز بهبود يابد. - در آدرس - http://openacs.org/philosophy/why-not-mysql.html - يك مقايسه جالب بين MySQL و - PostgreSQL وجود دارد. از طرف ديگر MySQL يك - شركت است كه محصول خود را به صورت متن باز ارائه ميكند ولي براي نرمافزار غير - متن باز خود احتياج به ليسانس تجاري دارد بر خلاف - PostgreSQL كه يك گروه كاملاً متن باز هستند.
PostgreSQL داراي يك -ساختار تشكيلاتي درجه اول است كه آن را مديون Marc Fournier -است كه اين ساختار را ايجاد كرده است.
-كيفيت يك ساختار براي يك پروژه متن باز بسيار -اهميت دارد. يك ساختار خوب ميتواند مانع از حوادثي شود كه در حركت روبهجلوي پروژه -خللي وارد ميكنند.
-البته اين ساختار تشكيلاتي ارزان نيست. هزينههاي -ثابت ماهانه و روزمره براي نگهداري و حفظ اين ساختار مورد نياز است. اگر شما يا -شركت شما مايل است كه از نظر مالي به اين حركت كمك كند لطفاً به سايت http://store.pgsql.com/shopping -مراجعه كرده و كمك خود را اهدا كنيد.
-هر چند در صفحه اصلي عبارت -PostgreSQL,Inc ذكر شده است ولي مشاركت عمدتاً براي پشتيباني از پروژه -PostgreSQL مي باشد و نه براي يك شركت مشخص. اگر ترجيح -ميدهيد ميتوانيد يك چك به آدرس مشخص شده ارسال كنيد.
-اگر يك استفاده موفق از -PostgreSQL سراغ داريد لطفاً آن را به سايت http://advocacy.postgresql.org گزارش -دهيد.
-دو درايور ODBC -بنامهاي psqlODBC و OpenLink براي -PostgreSQL وجود دارد.
-براي گرفتن psqlODBC -به سايت -http://gborg.postgresql.org/project/psqlodbc/projdisplay.php -مراجعه كنيد.
-OpenLlink را از اين -سايت http://www.openlinksw.com ميتوانيد -بگيريد. اين درايور با نرمافزارهاي مختلف ODBC كار -ميكند بنابراين شما قادر خواهيد بود با استفاده از OpenLink -روي اكثر سكوهايي كه نرمافزارODBCدارند بدون مشكل به -PostgreSQL نيز متصل شويد.
-اين محصول به كساني كه احتياج به خدمات پشتيباني -تجاري دارند فروخته ميشود. ولي نسخه آزاد اين نرمافزار هميشه در درسترس ميباشد. -براي كسب اطلاعات بيشتر سوالات خود را به آدرس postgres95@openlink.co.uk -ارسال نماييد.
-در سايت http://www.webreview.com براي استفاده از -PostgreSQL در صفحات وب راهنماييهاي خوبي وجود دارد.
-براي تركيب و استفاده در صفحات وب زبان -PHP يك واسط بسيار مناسب است. اطلاعات بيشتر راجع به -PHPدر سايت http://www.php.net وجود -دارد.
-مثالهايي نيز با استفاده از -Perl و CGI.pm و mod_perl -وجود دارد.
-چند نرم افزار گرافيكي براي -PostgreSQL وجود دارد كه شامل pgAccess درسايت http://www.pgaccess.org -و pgAdmin III در سايت http://www.pgadmin.org -و RHDB Admin در سايت http://sources.redhat.com/rhdb -و Rekall در سايت -http://www.thekompany.com/products/rekall - ميباشد. همچنين يك phpPgAdmin هم در سايت -http://phppgadmin.sourceforge.net وجود دارد كه يك -واسط وبي براي مديريت PostgreSQL ميباشد.
-براي ديدن اطلاعات بيشتر راجع به نرمافزارهاي -گرافيكي براي PostgreSQL به آدرس -http://techdocs.postgresql.org/guides/GUITools -مراجعه كنيد.
-بيشتر زبانهاي برنامهنويسي -ميتوانند با PostgreSQL ارتباط برقرار كنند. به همراه -سورس PostgreSQL تعدادي از واسطهاي مورد نياز براي ارتباط -با پايگاه داده از طريق زبانهاي مختلف آمده است كه در زير ليست آنها را مشاهده -ميكنيد.
-C (libpq)
Embedded C (ecpg) -
Java (jdbc)
Python (PyGreSQL) -
TCL (libpgtcl)
واسطهاي ديگر در -سايت http://gborg.postgresql.org -در قسمت Drivers/Interfaces وجود -دارد.
-موقع اجراي دستور -configure از گزينه prefix-- استفاده كنيد.
-به دلايل مختلف ممكن است اين اتفاق بيفتد. اما در -قدم اول شما مطمئن شويد كه كه امكانات اضافه System V -در كرنل شما نصب شده باشد. PostgreSQL براي اجرا شدن -نياز به استفاده از امكانات حافظه مشترك و سمافورها دارد.
-احتمالاً قسمت ايجاد حافظه مشترك در كرنل به -درستي تنظيم نشده است و يا اينكه بايد فضاي حافظه اشتراكي در كرنل را زياد كرد. -ميزان دقيق حافظه مشترك مورد نياز بسته به معماري و نحوه استفاده از بافرها توسط -برنامه postmaster دارد. براي بيشتر سيستمها كه -با تنظيمات پيشفرض كار ميكنند مقدار اين حافظه حدود 1 -مگابايت است. براي ديدن اطلاعات بيشتر راجع به حافظه مشترك و سمافور به -PostgreSQL Administrator's Guide مراجعه كنيد.
-اگر پيغام خطا -(pcSemaphoreCreate: semget failed (No space left on device - باشد به اين معني است كه تعداد سمافورهاي تنظيم شده در كرنل كافي نيست. -PostgreSQL براي هر فرايندي كه در -backend اجرا ميشود به يك سمافور نياز دارد. يك راه حل -موقت براي اين مسئله آن است كه postmaster را با -اعمال محدوديت روي تعداد فرايندهايي كه ميتواند ايجاد كند اجرا كنيم. براي اينكار -از گزينه N- و يك عدد كمتر از 32 استفاده كنيد. راه حل -دائمي اين مشكل آن است كه پارامترهاي SEMMNS, SEMMNI -كرنل را افزايش دهيم.
-در زمان دسترسي خيلي زياد به پايگاه داده، -سمافورهاي نامعتبر ميتوانند باعث crash كردن سيستم -شوند.
-اگر پيغام خطا چيز ديگري باشد احتمالاً به دليل -آن است كه كرنل از سمافورها پشتيباني نميكند. براي ديدن اطلاعات بيشتر راهنماي -مديريتي PostgreSQL را مطالعه كنيد.
-به صورت پيش فرض فقط از ماشيني كه -PostgreSQL روي آن در حال اجراست ميتوان با استفاده از -سوكتهاي يونيكسي به آن متصل شد. ساير ماشينها قادر نيستند به -PostgreSQL متصل شوند مگر آنكه گزينه tcp_sockets -در فايل postgresql.conf فعال شده و همچنين با اصلاح -فايل PGDATA/ph_hba.conf هويتشناسي مبتني بر ميزبان نيز -فعال شود. با اين كار ميتوان اتصالات TCP/IP به -PostgreSQL ايجاد كرد.
-به طور حتم استفاده از انديسها باعث بالا رفتن -سرعت پاسخگويي به درخواستها خواهد شد. دستور EXPLAIN ANALYZE -به شما امكان ديدن نحوه پردازش يك دستور توسط PostgreSQL -را ميدهد.
-اگر شما تعداد زيادي INSERT -داريد سعي كنيد آنها را با قرار دادن در يك فايل با دستور COPY -اجرا كنيد. اين دستور به مراتب از INSERT سريعتر است. -حتيالامكان سعي كنيد از تراكنشها استفاده نكنيد. تراكنشها مجموعه دستوراتي هستند -كه بيند BEGIN و COMMIT -ميآيند. اگر يك دستور به صورت عادي اجرا شود PostgreSQL -خود آن دستور را به صورت يك تراكنش مستقل نگاه كرده و اجرا ميكند. موقعی كه -تغييرات زيادي در پايگاه داده انجام ميشود انديسهاي قبلي را حذف و مجدداً ايجاد -كنيد.
-استفاده از گزينه o -F- -در فرمان postmaster باعث غير فعال كردن -()fsync ميشود. اين دستور بعد از هر تراكنش اطلاعات را -روي هاردديسك منتقل ميكند.
-براي افزايش تعداد بافرهاي حافظه اشتراكي از -گزينه B- به همراه فرمان -postmaster استفاده كنيد. توجه كنيد كه اگر اين عدد خيلي بزرگ باشد ممكن -است postmaster اصلاً اجرا نشود. هر بافر 8 كيلو -بايت حافظه نياز دارد و تعداد بافرها به طور پيش فرض 64 است.
-همچنين ميتوان با گزينه S- -ميزان حافظهاي كه براي مرتبسازيهاي موقت توسط PostgreSQL -استفاده ميشود را افزايش داد. مقدار پيش فرض 512 كيلو بايت است.
-استفاده از دستور CLUSTER -نيز براي بالا بردن كارايي موثر ا ست. دستور راهنماي CLUSTER -اطلاعات بيشتري در اين زمينه به شما ميدهد.
-PostgerSQL امكانات -مختلفي براي گزارش دادن وضعيت خود دارد كه براي اشكال زدايي ميتوان از آنها -استفاده كرد.
-با استفاده از گزينه -enable-assert-- -تعداد زيادي ()assert براي مونيتور كردن و توقف برنامه -در صورت بروز خطاهاي ناخواسته فعال ميشود.
-هم Postmaster -و هم postgres گزينههاي زيادي براي اشكال زدايي -دارند. موقعي كه postmaster را اجرا ميكنيد -خروجي استاندارد و خطا را سمت فايل log ارسال كنيد.
-cd /usr/local/pgsql - ./bin/postmaster >server.log 2>&1 & --
اين كار يك فايل -log -در بالاترين شاخه PostgreSQL ايجاد ميكند. اين فايل -حاوي اطلاعات مفيدي در مورد مسائل و خطاهايي است كه براي سرور اتفاق افتاده است. -براي ديدن جزئيات بيشتر ميتوان از d- به همراه -فرمان postmaster استفاده كرد. گزينه -d- همچنين يك عدد ميگيرد كه نشان دهنده سطح جزئياتي است -كه در Logفايل نوشته ميشود. با بالابردن اين عدد حجم -اطلاعات توليد شده در Logفايل نيز افزايش مييابد.
-اگر postmaster -در حال اجرا نباشد، ميتوانيم postgres را به طور مستقيم -از خط فرمان اجرا كرده و دستورات SQL را به آن -بدهيم. اين كار فقط براي اشكاليابي توصيه ميشود. توجه كنيد كه در اين حالت يك -دستور با كاراكتر newline خاتمه پيدا ميكند و نه با -;. اگر postmaster را با -امكانات اشكاليابي كامپيل كرده باشيد ميتوانيد با استفاده از يك برنامه اشكالياب -اجراي برنامه را مونيتور كنيد.
-اگر postmaster -در حال اجرا باشد با دستور psql ميتوان به -postgres متصل شد. با پيدا كردن PID -فرايند postgres كه psql به -آن متصل شده است ميتوان آن را مونيتور كرد. براي اينكار بايد يك برنامه اشكالياب -را به آن pid متصل كرد. اگر بخواهيم بالا آمدن -postgres را مونيتور كنيم كافي است -"PGOPTIONS="-W n و psql -را اجرا كنيم. اين كار باعث ميشود كه postgres با -n ثانيه تاخير اجرا شود و در اين فاصله شما ميتوانيد -برنامه اشكالياب را به آن متصل كرده و با قرار دادن يك نقطه توقف روند اجراي -آن را مونيتور كنيد.
-postgres -گزينههاي s- و A- و -t- دارد كه براي پيدا كردن اشكالات بسيار مناسب هستند.
-شما ميتوانيد postgreSQL -را با امكانات profiling كامپيل كنيد. اين كار باعث -ميشود كه زمان اجراي دقيق هر تابع در برنامه مشخص شود. خروجيهاي توليد شده در اين -حالت در فايل DLINUX_PROFILE. ريخته ميشود.
-شما بايد حداكثر تعداد فرايندهاي همزمان -postmaster را افزايش دهيد. مقدار پيش فرض 32 است. -براي افزايش آن ميتوان از گزينه N- استفاده كرد و يا -فايل postgresql.conf را اصلاح نمود
-توجه كنيد كه اگر N- -مقداري بيشتر از 32 داشته باشد بايد مقدار B- را نيز -افزايش دهيم. اين مقدار بايد حداقل دو برابر مقدار N- -باشد. براي اعداد خيلي بالا بايد بعضي از پارامترهاي كرنل را نيز اصلاح كرد. -پارامترهايي نظير حداكثر اندازه حافظه اشتراكي SHMMAX ، -حداكثر تعداد سمافورها SEMMNI و -SEMMNS ، حداكثر تعداد فرايندها NPROC، حداكثر -فرايندهاي يك كاربر MAXUPRC و حداكثر فايلهاي باز -NFILE و NINODE. يكي از -دلايلي كه تعداد اتصالات همزمان postgreSQL محدود است آن -است كه نيازهاي PostgreSQL بيش از منابع موجود سيستم -نباشد.
-دراين شاخه فايلهاي موقتي قرار دارد كه با اجراي -درخواستها به وجود آمده است. به عنوان مثال اگر براي اجراي دستور -order by نياز به انجام مرتب سازي باشد و در صورتي كه -حافظه مشخص شده با گزينه S- براي اينكار كافي نباشد -سيستم يك فايل موقت در اين شاخه ايجاد ميكند تا عمل مرتب سازي را انجام دهد.
-فايلهاي موقت معمولاً به صورت اتوماتيك پاك -ميشود اما اگر postgreSQL در حين مرتب سازي -crash كند آن فايلها باقي ميمانند. با -stop و start كردن برنامه -postmaster اين فايلها پاك ميشوند.
-تيم برنامه نويس postgreSQL -در نسخههاي ارائه شده كه فقط minor آنها متفاوت است فقط -تغييرات كوچكي اعمال ميكنند؛ بنابراين براي به روز كردن از نسخه -7.2به 7.2.1 نيازي به -dump و restore نيست. اما در -نسخههايي كه major آنها تغيير ميكند غالباً ساختار -داخلي جداول و فايلهاي داده تغيير ميكند. اين تغييرات معمولاً پيچيده هستند. براي -انتقال دادههاي موجود در پايگاه داده در اين حالت بايد از -dump و restore استفاده كرد.
-در نسخههايي كه ساختار روي ديسك تغييري نميكند -مي توان از برنامه pg_upgrade براي به روز كردن پايگاه -داده استفاده كرد بدون اينكه نيازي به استفاده از dump و -restore باشد. در يادداشتي كه به همراه هر توزيع ميآيد -ذكر شده است كه آيا برنامه pg_upgrade براي اين توزيع -وجود دارد يا خير.
-چون اكثر سختافزارهاي PC - سازگار هستند مردم فكر ميكنند كه كيفيت آنها نيز يكسان است. در حاليكه -اينطور نيست. استفاده از هاردهاي SCSI و حافظههاي -ECC و مادربردهاي با كيفيت بالا نسبت به سخت افزارهاي ارزانتر نتايج بهتري -از نظر كارايي و پايداري سيستم بهمراه خواهد داشت. -PostgreSQL روي بيشتر سخت افزارها اجرا ميشود اما اگر كارايي و اطمينان -فاكتورهاي مهمي هستند بايد سخت افزار مناسب استفاده شود. در گروههاي پستي در مورد -سخت افزار مناسب و انتخاب آن بحث شده است.
-راهنماي دستور DECLARE -را مطالعه كنيد.
-راهنماي دستور FETCH - يا SELECT...LIMIT را ببينيد.
-در واقع كل درخواست بايد بررسي و -ارزيابي شود حتي اگر شما فقط چند رديف اول را بخواهيد. براي مثال درخواست -ORDER BY را در نظر بگيريد. اگر انديس يا نمايهاي براي -ORDER BY وجود داشته باشد،postgreSQL -ممكن است بتواند فقط چند سطر اول درخواستي را ارزيابي كند و يا اينكه كل درخواست -پردازش شود تا تعداد رديفهاي درخواستي توليد شود.
-براي انتخاب يك سطر تصادفي به -روش زير عمل ميكنيم:
SELECT col - FROM tab - ORDER BY random() - LIMIT 1; --
براي ديدن ليست جداول دستور -dt\ را در برنامه psql -استفاده كنيد. براي ديدن ليست كامل فرمانها ?\ را اجرا -كنيد. راه ديگر خواندن متن برنامه psql است كه در شاخه - pgsql/src/bin/psql/describe.c قرار -دارد. اين فايل حاوي فرامين SQLيي است كه خروجي را -براي دستوراتي كه با \در psql -شروع ميشوند توليد ميكنند. راه ديگر اجراي psql با گزينه -E-است. اينكار باعث ميشود كه psql -قبل از اجرا هر دستور SQLمتناظر آن را نشان دهد. -PostgreSQLهمچنين يك برنامه SQLi دارد كه -ميتوان با استفاده از آن اطلاعات داخلي پايگاه داده را استخراج كرد.
-حذف يك ستون در توزيع 7.3 -با استفاده از دستور ALTER TABLE DROP COLUMN -اضافه شده است. در نسخههاي قبلي به روش زير عمل كنيد:
- BEGIN;
- LOCK TABLE old_table;
- SELECT ... -- تمام ستونها غير از ستوني كه ميخواهيد آن را حذف كنيد را در اينجا بياوريد
- INTO TABLE new_table
- FROM old_table;
- DROP TABLE old_table;
- ALTER TABLE new_table RENAME TO old_table;
- COMMIT;
-
-براي عوض كردن نوع داده يك ستون -به روش زير عمل كنيد:
-BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; --
محدوديتها عبارتند از:
-حداكثر اندازه پايگاه داده نامحدود (تا 32 ترابايت وجود دارد) - حداكثر اندازه يك جدول 32 ترابايت - حداكثر ا ندازه يك رديف 1.6 ترابايت - حداكثر اندازه يك فيلد 1 گيگا بايت - حداكثر اندازه رديفهاي يك جدول نا محدود - حداكثر ستونهاي يك جدول بسته به نوع جدول بين 250 تا 6000 - حداكثر انديسهاي يك جدول نا محدود -
البته در حالت نامحدود نيز ما -محدود به حجم هاردديسك و فضاي حافظه خواهيم بود. در صورتي که مقادير مشخص شده به -عنوان نامحدود به صورت غير معمولي بزرك شوند كارايي سيستم كاهش خواهد يافت.
-براي ذخيره كردن جداول با اندازه -خيلي بزرگ نيازي نيست كه سيستم عامل امكان ايجاد فايلهاي بزرگ را داشته باشد. بلكه -جداول خيلي بزرگ به صورت فايلهايي به حجم يك گيگا بايت نگاهداري ميشوند.
-اگر اندازه بلوكهاي داده را -برابر 32 كيلو بايت قرار دهيم حداكثر اندازه جدول و حداكثر تعداد ستونها 4 برابر -خواهد شد.
-يك پايگاه داده -PostgreSQL تا 5 برابر فضايي روي هاردديسك براي نگاهداري يك فايل -متني نياز دارد.
-به عنوان مثال يك فايل با 100000 -خط را در نظر بگيريد كه در هر خط يك عدد صحيح و يك توضيح متني آمده است. فرض كنيد -كه رشته متني به طور متوسط 20 بايت باشد. اندازه فايل برابر 2.8 مگا بايت خواهد بود -ولي PostgreSQL براي نگاهداري اين فايل به 6.4 مگا بايت -اطلاعات نياز خواهد داشت.
-32 bytes: اندازه سرايند هر خط به طور تقريبي - 24 bytes: يك عدد صحيح و يك رشته 24 بايتي - + 4 bytes: اشاره گر روي صفحه به يك چندتايي - ---------------------------------------- - 60 bytes در هر رديف - -اندازه صفحات داده در PostgreSQL برابر با 8 كيلو بايت است - 8192 تعداد بايتها در هر صفحه - ------------------- = 136 تعداد رديفها در يك صفحه پايگاه داده - 60 تعداد بايتهاي هر رديف - - 100000 تعداد رديفها - -------------------- = تعدادصفحات پايگاه داده - 128 تعداد رديفها در هر صفحه - -735 تعداد صفحات * 8192 تعداد بايتهاي هر صفحه = 6,021,120 مگا بايت --
سربار انديسها يا نمايهها از -اين مقدار كمتر است ولي چون شامل خود دادهها هم هست -ممکن است اندازه آنها هم بزرگ شود.
-NULLها به صورت bitmap -ذخيره ميشوند و از اينرو فضاي بسيار كمي را اشغال ميكنند.
-psql -تعداد زيادي دستور دارد كه با \ شروع -ميشوند و اين اطلاعات را در اختيار ما قرار ميدهند. براي ديدن آنها دستور -?\ را اجرا كنيد. همچنين جداول سيستمي كه با نام آنها -pg_ شروع ميشود نيز اين اطلاعات -را در خود دارند. اجراي برنامه psql با گزينه l- - نيز باعث نشان دادن ليست تمام پايگاههاي داده ميشود.
-همچنين فايل -pgsql/src/tutorial/syscat.source -نيز فرمانهاي SELECT كه با -استفاده از آن ميتوان اطلاعات پايگاه داده را استخراج كرد شرح داده است.
-به طور معمول -براي درخواستها از نمايهها استفاده نميشود. -تنها در صورتي از نمايهها استفاده ميشود كه اندازه جدول از يك اندازه حداقل -بزرگتر باشد و درخواست هم فقط قسمتي از رديفهاي جدول را انتخاب كرده باشد. دليل -اين كار آن است كه دسترسيهاي تصادفي به هاردديسك كه به خاطر نمايهها ايجاد ميشود -ممكن است از خواندن مستقيم جدول يا خواندن ترتيبي ركوردها كندتر باشد.
-براي تعيين اينكه از نمايه -استفاده شود يا خير، PostgreSQL بايد اطلاعات آماري را در -مورد يك جدول بداند. اين اطلاعات توسط دستور ANALYZE و -VACUUM ANALYZE به دست ميآيد. با استفاده از اين اطلاعات، -بهينه ساز از تعداد رديفهاي يك جدول اطلاع پيدا ميكند و بهتر ميتواند تعيين كند -كه آيا از نمايه استفاده شود يا خير. اطلاعات آماري همچنين براي تعيين ترتيب الحاق -و روشهاي الحاق به صورت بهينه نيز كاربر دارد. جمع آوري اطلاعات آماري بايد به صورت -دورهاي همزمان با تغيير دادههاي جدول انجام شود.
-نمايهها به طور معمول همراه با -دستور ORDER BY به كار برده نميشوند. براي يك جدول بزرگ يك -پيمايش ترتيبي همراه با دستور مرتب سازي از به كار بردن نمايهها سريعتر خواهد بود.
-اما اگر همراه با ORDER -BY از LIMIT استفاده شود اغلب از نمايهها -استفاده ميشود چون فقط قسمتي از جدول استفاده ميشود. در حقيقت هر چند -توابع ()MIN و ()MAX -از نمايهها استفاده نميكنند ولي ميتوانيم با استفاده از دستور -زير با استفاده از نمايهها و دستور ORDER BY و -LIMIT آنها را به دست آوريم.
-SELECT col - FROM tab - ORDER BY col [ DESC ] - LIMIT 1; --
اگر شما فكر ميكنيد كه بهينه
-ساز سيستم در انتخاب پيمايش ترتيبي اشتباه كرده است با دستور 'SET
-enable_seqscan TO 'off'
-ميتوانيد ببينيد آيا استفاده از نمايهها باعث افزايش سرعت درخواستها خواهد شد.
استفاده از نمايهها هنگامي كه -از علائم ويژه نظير LIKE و ~ -استفاده ميكنيد فقط در بعضي شرايط خاصي كه در اينجا ذكر شده است ممكن است:
-ابتداي رشته جستجو بايد به - طور صريح مشخص باشد براي مثال:
دستورات - LIKE نبايد با علامت % شروع - شوند
الگوهاي منظمي كه با - ~ ميايد حتماً بايد با علامت ^ شروع - شود
رشته جستجو نبايد با يك - مجموعه از كاراكترها مثل [a-e] شروع شود
جستجوهاي غيرحساس به متن مثل - ILIKE و *~ از نمايهها - استفاده نميكنند. در عوض از توابع نمايهاي كه در قسمت - 4.12 - توضيح داده شد استفاده ميكنند.
مقدار پيش فرض locale - بايد در initdb استفاده شود.
راهنماي دستور EXPLAIN -را نگاه كنيد.
-از نمايه R-Tree - براي انديس كردن دادههاي فاصلهاي استفاده ميشود. يك نمايه -hash نميتوانند جستجوهاي محدودهاي را انجام دهد. نمايه -"B-tree" نيز براي انجام جستجوي محدودهاي در يك جهت قابل استفاده -است. اما R-Tree ميتواند دادههاي چند بعدي را نيز -پشتيباني كند. براي مثال استفاده اگر از نمايه R-tree براي -گونه Point استفاده شود سرعت درخواستهايي نظير "select -all points within a bounding rectangle" به مراتب افزايش مييابد.
-مقالهاي كه طراحي R-tree -را توضيح داده است
-Guttman, A. "R-trees: A Dynamic Index Structure for -Spatial Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt of -Data, 45-57.
-R-tree ميتواند چندضلعيها و -چند وجهي را پشتيباني كند. در تئوري R-tree ميتواند تعداد -بعدهاي بالاتر ري نيز پشتيباني كند. در عمل توسعه R-tree -نياز به كار بيشتري دارد.
-استفاده از GEQO -سرعت بهينه سازي درخواست را هنگاميكه تعداد زيادي جدول را با استفاده از الگوريتم -ژنتيك الحاق ميكنيم افزايش ميدهد.
-براي جستجوي عبارت منظم از عملگر -~ استفاده ميكنيم. براي جستجوي غير حساس به متن از عملگر -*~ و يا ILIKE استفاده ميكنيم.
-روش ديگر انجام جستجوي غير حساس -به متن در زير نشان داده شده است.
-SELECT * - FROM tab - WHERE lower(col) = 'abc'; --
اين از نمايههاي استاندارد -استفاده نميكند. ولي شما مي توانيد با دستور زير يك نمايه ايجاد كنيد و از آن -استفاده كنيد.
-CREATE INDEX tabindex ON tab (lower(col)); --
با استفاده از توابع IS -NULL و IS NOT NULL ميتوانيم NULL -بودن يك فيلد را تست كنيم.
-Type Internal Name Notes --------------------------------------------------- -VARCHAR(n) varchar اندازه، حداكثر طول را نشان مي دهد بدون اضافه شدن كاراكتر اضافه -CHAR(n) bpchar كاراكترهاي بلانك براي پر شدن طول مشخص شده استفاده ميشود -TEXT text حداكثر طول را مشخص نميكند -BYTEA bytea آرايهاي از بايت با طول متغير -"char" char يك كاراكتر --
نام داخلي گونهها را در -system catalogue و بعضي از پيغامهاي خطا ميتوان ديد.
-چهار گونه اول همگي از نوع -varlena هستند (4 بايت اول روي ديسك طول را مشخص ميكند كه -به دنبال آن دادهها قرار دارند.)بنابراين فضاي واقعي استفاده شده روي ديسك از -اندازه تعريف شده بيشتر است. اما اين گونهها را ميتوان فشرده كرد كه اينكار باعث -ميشود فضاي كمتري روي ديسك اشغال كنند.
-براي ذخيره رشتههاي با طول -متغير(VARCHAR(n -بهترين انتخاب است. در اين گونه حداكثر طول رشته محدود است بر خلاف -text كه هيچ محدوديتي روي حداكثر -اندازه رشته نميگذارد.(در اين گونه حداكثر طول يك رشته يك گيگا بايت خواهد بود)
-گونه (CHAR(n - براي ذخيره دادههاي با طول يكسان است.يك گونهي -(CHAR(n -با كاراكترهاي بلانك (خالي) پر ميشود تا به طول مشخص شده برسد در -حاليكه گونه VARCHAR -كاراكترها را به همان صورت كه هستند ذخيره ميكند. گونه BYTEA -براي ذخيره دادههاي باينري است به خصوص دادههاي باينتري كه شامل بايتهاي -NULL هستند. از نظر كارايي تمام اين گونهها يكسان هستند.
-PostgreSQL از دادههاي سريال -پشتيباني ميكند. براي ايجاد يك فيلد سريال (براي داشتن يك فيلد منحصر به فرد براي -هر رديف )به روش زير عمل كنيد:
-CREATE TABLE person ( - id SERIAL, - name TEXT - ); --
دستور بالا به طور اتوماتيک به -دستور زير تبديل ميشود:
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
-
-براي ديدن اطلاعات بيشتر به -راهنماي دستور create_sequence مراجعه كنيد. -همچنين ميتوان از OIDهر رديف به عنوان يك مقدار منحصر به -فرد استفاده كرد. اما در اين حالت براي dump كردن و -reloadكردن پايگاه داده بايد دستور pg_dumps -را با گزينه o- اجرا كنيد.
-يك روش براي گرفتن مقدار بعدي يك -فيلد سريال استفاده از تابع ()nextval است. -در شبه كُدي كه در ادامه آمده است روش انجام اين كار نشان داده شده -است:
- new_id = execute("SELECT nextval('person_id_seq')");
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
-
-با اجرا دستور فوق مقدار جديد را -در متغير new_id نيز خواهيدداشت كه ميتوانيد آن را در بقيه -درخواستهاي نيز استفاده كنيد. توجه داشته باشيد كه نام SEQUENCEيي -كه به طور اتوماتيك ايجاد شده است به صورت table_serialcolumn_seq -خواهد بود. كه در آن -table نام جدول و serialcolumn نام فيلد -سريال جدول ميباشد.
-براي ديدن مقدار نسبت داده شده -به فيلد سريال نيز ميتوان از تابع () currval -به صورت زير استفاده كرد.
- execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
- new_id = execute("SELECT currval('person_id_seq')");
-
-و سرانجام شما ميتوانيد از -مقدار OID كه خروجي دستور INSERT - است براي ديدن مقدار پيش فرض استفاده كنيد. هر چند اين روش در همه پلتفرمها قابل -استفاده نيست و ضمن اينكه فيلد oid بعد از عدد 4 ميليارد -دوباره صفر ميشود. در زبان perl با استفاده از DBI -و DBD::Pg مقدار oidرا ميتوانيد -به شكل زير استخراج كنيد: بعد از اجراي ()st->execute$ -مقدار oid در متغير sth->pg_oid_status$ -ذخيره خواهد شد.
-خیر، استفاده از این توابع شرایط -race را به وجود نمی آورد.
-برای بالا بردن امکان اجرای -همزمان تراکنشها، اعداد سریالی به محض اجرای تراکنش به آنها تخصیص می یابد در این -حالت اگر بعضی از تراکنشها abort شوند بین اعداد سریالی -استفاده شده یک فاصله خالی به وجود می آید.
-OID راه حل PostgreSQL -برای داشتن یک شناسه منحصر به فرد برای هر ردیف است. هر ردیف جدیدی که ایجاد می شود -یک OID منحصر به فرد به آن اختصاص می یابد. تمام OIDهایی -که در حین initdb ایجاد می شوند از 16384 کمتر هستند و -OIDهایی بعداً تولید می شود از این عدد بزرگتر خواهد بود. -نکته مهم آن است که OIDها نه تنها در یک جدول شبیه نیستند -بلکه در کل پایگاه داده هیچ دو ردیفی دارای OID یکسان -نخواهد بود.
-PostgreSQL از OID -در سیستم داخلی خود برای ایجاد ارتباط بین ردیفهای جداول مختلف استفاده می کند. -توصیه می شود که یک ستون از نوع OID برای ذخیره این فیلد در -جدول ایجاد کنید. ساختن یک نمایه برای این فیلد باعث دسترسی سریعتر به آن خواهد شد.
-تمام پایگاههای داده در -PostgreSQL برای گرفتن OID جدید از یک -ناحیه مرکزی استفاده می کند. ولی اگر بخواهیم OID را به روش -دیگری بگیریم و یا اینکه در حین کپی کردن یک جدول بخواهیم OIDهای -اصلی آن تغییر نکند به روش زیر می توانیم عمل کنیم:
--
CREATE TABLE new_table(mycol int); - SELECT oid AS old_oid, mycol INTO tmp_table FROM old_table; - COPY tmp_table TO '/tmp/pgtable'; - COPY new_table WITH OIDS FROM '/tmp/pgtable'; - DROP TABLE tmp_table; --
OID یک عدد صحیح 4 بایتی است و -بنابراین حداکثر مقدار آن 4 میلیارد خواهد بود و بعد از آن مقدار آن سرریز خواهد -شد. البته تا کنون برای کسی این اتفاق نیفتاده است و تصمیم -گرداندگان PostgreSQL آن است که قبل از آنکه این اتفاق رخ -دهد این مشکل را برطرف کنند.
-TIDها برای شناسایی محل فیزیکی -یک ردیف بر اساس بلوک و آفست می باشد. TIDها بعد از تغییر -پیدا کردن یک ردیف و یا بازخوانی آن عوض می شوند. TIDها -توسط نمایه ها استفاده می شوند.
-لیست برخی از ترمها و کلماتی که -استفاده می شوند:
-table, relation, class - :کلاس، رابطه، جدول
row, record, tuple چندتایی، - رکورد، ردیف
column, field, attribute - صفت، فیلد، ستون
retrieve, select انتخاب، - خواندن
replace, updateبه روز کردن، - جایگزینی - -
append, insert درج، اضافه - کردن
OID, serial value - مقدار سریال
portal, cursor - -
range variable, table name, table alias -
یک لیست عمومی از ترمهای مورد -استفاده در پایگاه داده در آدرس -http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary/glossary.htm -وجود دارد.
-این خطا احتمالاً یا به خاطر -تمام شدن حافظه مجازی سیستم شماست و یا اینکه کرنل برای برنامه ها در مورد میزان -استفاده از حافظه مجازی محدودیت اعمال کرده است. قبل از اجرای برنامه اصلی یکی از -دستورات زیر را اجرا کنید.
-ulimit -d 262144 - limit datasize 256m -
بسته به نوع شل یکی از این -دستورات ممکن است با موفقیت اجرا شود. با اجرای آن دستور محدودیت حافظه مجازی برای -برنامه ها برداشته شده و با این کار احتمالاً درخواستی که قبلاً خطا می داده است -اجرا خواهد شد.
-با اجرای دستور -()SELECT version
-شما باید قبل از -شروع دستوراتی که با large-objectها کار می کنند از -BEGIN و بعد از آنها هم یک END -بگذارید. در حال حاضر PostgreSQL هندل large-objectها -را در زمان نهایی شدن تراکنش (commitشدن) -می بندد. به همین دلیل اولین تلاش برای انجام هر کاری با هندل منجر -به خطای invalid large obj descriptor خواهد شد. -برای جلوگیری از این خطا حتماً باید از یک تراکنش استفاده کنید. -این کار همانطور که قبلاً گفته شد با استفاده از قرار دادن BEGIN -و END در ابتدا و انتهای دستورات انجام می شود.
-اگر این خطا را در حین استفاده
-از یک درایور ODBC دریافت کردید احتمالاً باید این دستور را
-اجرا کنید: set auto-commit off
از CURRENT_TIMESTAMP - استفاده کنید در مثال زیر نحوه انجام -این کار نشان داده شده است:
-CREATE TABLE test (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP );
-
-در نسخه های قبل از 7.4 عمل -الحاق زیر درخواست و درخواست اصلی به این صورت انجام می شود که نتایج به دست آمده -از زیر درخواست به صورت ترتیبی برای هر ردیف اعمال می شود. اگر زیردرخواست ردیف های -کمی را به عنوان خروجی برگرداند و درخواست بیرونی ردیف های زیادی را شامل شود -استفاده از IN بهترین روش است در غیر اینصورت بهتر است از -EXISTS استفاده شود
-SELECT * - FROM tab - WHERE col IN (SELECT subcol FROM subtab); -
به:
-SELECT * - FROM tab - WHERE EXISTS (SELECT subcol FROM subtab WHERE subcol = col); -
برای اجرای سریع این درخواست -باید برای ستون subcol نمایه ایجاد شده باشد.
-در نسخه های بعد از 7.4 -IN برای الحاق از همان تکنیک پیچیده مورد استفاده در دستورات -معمولی استفاده می کند و بنابراین استفاده از آن نسبت به EXISTS -ارجحیت دارد.
برای انجام الحاق خارجی به روش -زیر عمل کنید:
-SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -
یا
-SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); --
درخواستهای بالا t1.col , -t2.col را به هم الحاق می کند و همچنین ردیفهای t1 -که نظیر آنها در t2 نبوده است را نیز برمی گرداند. اگر از -RIGHT استفاده شود نتیجه بر عکس است. یعنی ردیفهای -t2 که نظیر آنها در t1 نباشد را نشان می -دهد و اگر از FULL استفاده شود نتیجه هم شامل ردیفهای -t1 است و هم شامل ردیفهای t2. -استفاده از کلمه OUTER اختیاری است چرا که این کلمه به طور -ضمنی دستورهای LEFT, RIGHT, FULL وجود دارد.
-در نسخه های قبلی پایگاه داده می
-توانیم الحاق خارجی را به کمک دستورهای UNION, NOT IN شبیه
-سازی کنیم. این کار در مثال زیر نشان داده شده است:
SELECT tab1.col1, tab2.col2 - FROM tab1, tab2 - WHERE tab1.col1 = tab2.col1 - UNION ALL - SELECT tab1.col1, NULL - FROM tab1 - WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2) - ORDER BY col1 --
در حال حاضر این کار امکان پذیر -نیست. PostgreSQL فقط امکان درخواست از پایگاه داده ای را -می دهد که در حال حاضر به آن متصل باشید و نمی توان به طور همزمان از دو پایگاه -داده استفاده کرد. البته یک برنامه کاربردی خود می تواند به طور همزمان دو -پایگاه داده را مورد استفاده قرار داده و نتایج را با هم ترکیب کند ولی نمی تواند -در یک درخواست به هر دو پایگاه داده رجوع کند.
-در نسخه 7.3 خروجی یک تابع می -تواند چند ردیف یا چند ستون باشد. برای دیدن اطلاعات بیشتر به سایت زیر -مراجعه کنید:http://techdocs.postgresql.org/guides/SetReturningFunctions -
PL/PgSQL محتوای توابع را ذخیره -(cache) می کند. یک اثر بد جانبی -این کار آن است که اگر در تابع از یک جدول موقت استفاده شود و بعداً آن جدول حذف و -یک جدول جدید به جای آن ایجاد شود، در فراخوانی مجدد آن تابع، محتوای ذخیره -شده تابع هنوز به جدول قدیمی اشاره می کند و بنابراین اجرای تابع با اشکال -مواجه می شود. راه حل این مشکل آن است که برای جداول موقت از دستور EXECUTE -استفاده شود که این کار سبب می شود که درخواست برای هر بار اجرا مجدداً پیمایش و -تفسیر شود.
-There are several master/slave replication -options available. These allow only the master to make database changes and the -slave can only do database reads. The bottom of -http://gborg.PostgreSQL.org/genpage?replication_research -lists them. A multi-master replication solution is being worked on at -http://gborg.PostgreSQL.org/project/pgreplication/projdisplay.php.
-contrib/pgcrypto - شامل توابع رمزنگاری زیادی است که می توان از آنها در دستورات SQL - استفاده کرد.
برای رمز کردن ارتباط بین - client و server ، پایگاه داده - حتماً گزینه SSL را بر روی پایگاه داده فعال کنیم.
در نسخه 7.3 به بعد کلمات - عبور کاربران به طور اتوماتیک به صورت رمز شده ذخیره می شود ولی در نسخه های - قبلی باید گزینه - PASSWORD_ENCRYPTION در فایلpostgresql.conf - فعال کنیم. - -
می توان پایگاههای داده را - روی یک فایل سیستم رمزشده نگاهداری کرد
دلایل مختلفی می تواند باعث بروز -این مشکل شود. اما قبل از همه تابع خود را به صورت جدا تست کنید.
-کد خود را به گروه پستی - pgsql-hackers - ارسال کنید.
-در نسخه های 7.3 به بعد یک تابع -می تواند یک جدول را به عنوان خروجی برگرداند. این ویژگی در توابعی که به زبانهای -C و PL/PgSQL نوشته می شوند به طور -کامل وجود دارد. راهنما برنامه نویسان را مطالعه کنید. یک مثال از نحوه برگرداندن -یک جدول به عنوان خروجی در contrib/tablefunc آمده -است.
-Makefile برای فایلهای -include شده وابستگیها را به درستی نشان نمی دهد. برای اطمینان از -اینکه فایلی که عوض کرده اید حتماً دوباره کامپیل می شود دستور make clean -را اجرا کنید. اگر از کامپیلر gcc استفاده می کنید می -توانید از گزینه enable-depend-- در موقع اجرای برنامه -configure استفاده کنید این گزینه باعث می شود که وابستگیها -به طور اتوماتیک تولید شود.
\ No newline at end of file diff --git a/doc/src/FAQ/FAQ_french.html b/doc/src/FAQ/FAQ_french.html deleted file mode 100644 index 12f33422e26..00000000000 --- a/doc/src/FAQ/FAQ_french.html +++ /dev/null @@ -1,1466 +0,0 @@ - - - - - -Dernire mise jour : vendredi 14 novembre 2004 16:32:47
- -Mainteneur actuel : Bruce Momjian (pgman@candle.pha.pa.us)
-
La plus rcente version de ce document est disponible sur http://www.PostgreSQL.org/docs/faqs/FAQ.html.
- -Les questions spcifiques la plateforme sont rpondues sur http://www.PostgreSQL.org/docs/index.html.
-IN sont-elles si lentes ?PostgreSQL se prononce Post-Gres-Q-L. Un fichier audio est - disponible sur http://www.postgresql.org/postgresql.mp3 - pour ceux souhaitant entendre la prononciation.
- -PostgreSQL est une amlioration du systme de gestion de bases - de donnes POSTGRES (et est toujours quelque fois appel "Postgres"), - un prototype de recherche de - SGBD de prochaine gnration. PostgreSQL garde le - puissant modle de donnes et les types de donnes riches de - POSTGRES, mais remplace le langage de requtes PostQuel par un - sous-ensemble tendu de SQL. PostgreSQL est gratuit - et les sources complets sont disponibles.
- -PostgreSQL est crit par une quipe de dveloppeurs qui sont - tous inscrits la liste de diffusion de dveloppement de - PostgreSQL. Le coordinateur actuel est Marc G. Fournier (scrappy@PostgreSQL.org et voir - la section 1.6 pour contacter les - dveloppeurs). Cette quipe est responsable de tout le - dveloppement de PostgreSQL. C'est un projet soutenu par une - communaut sans tre contrl par une socit. Pour y contribuer, - voir la FAQ des dveloppeurs sur http://www.postgresql.org/docs/faqs/FAQ_DEV.html.
- -Les auteurs de PostgreSQL 1.01 taient Andrew Yu et Jolly Chen. - Beaucoup d'autres personnes ont contribu au portage, aux tests, - au dboguage et l'amlioration du code. Le code de Postgres - original, duquel PostgreSQL est driv, tait le fruit de - l'effort de nombreux tudiants diplms et non diplms, et de - programmeurs travaillant sous la direction du Professeur Michael - Stonebraker l'universit de Californie, Berkeley.
- -Le nom original du logiciel Berkeley tait Postgres. Quand le - SQL fut ajout en 1995, le nom a d tre chang en - Postgres95. Fin 1996, le nom fut chang en PostgreSQL.
- -PostgreSQL est distribu sous la licence suivante :
- -PostgreSQL Data Base Management System
- -Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-6 Regents of the University of California
- -Permission to use, copy, modify, and distribute this software - and its documentation for any purpose, without fee, and without a - written agreement is hereby granted, provided that the above - copyright notice and this paragraph and the following two - paragraphs appear in all copies.
- -IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL - DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS - SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF - CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- -THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE - SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE - UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, - SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- -La licence ci-dessus est la licence BSD, une licence open-source - classique.
- -En gnral, tout environnement compatible Unix moderne devrait - pouvoir faire fonctionner PostgreSQL. Les environnements qui ont t - tests explicitement sont lists dans les instructions - d'installation.
- -partir de la version 8.0, PostgreSQL fonctionne nativement sur les - systmes d'exploitation Microsoft Windows base NT comme Win2000, WinXP et Win2003. - Un installeur est disponible sur - http://pgfoundry.org/projects/pginstaller.
- -Il existe aussi un port sur Novell Netware sur - http://forge.novell.com.
- -Le site FTP anonyme principal de PostgreSQL est ftp://ftp.PostgreSQL.org/pub. - Pour les sites miroirs, voir notre site web principal.
- -La liste de diffusion principale est pgsql-general@PostgreSQL.org. - Elle est disponible pour discuter de sujets en rapport avec - PostgreSQL. Pour s'y inscrire, il faut envoyer un courriel avec - les lignes suivantes dans le corps du message (pas dans la ligne - du sujet) :
-- subscribe - end -- -
pgsql-general-request@PostgreSQL.org.
- -Il existe aussi un recueil de la liste. Pour s'y inscrire, - envoyez un courriel pgsql-general-digest-request@PostgreSQL.org - avec dans le corps :
-- subscribe - end -- - Les recueils sont envoys aux membres de cette liste ds que la - liste principale a reu 30 Ko de messages. - -
Une liste de diffusion de bogues est disponible. Pour s'y inscrire, - envoyer un courriel pgsql-bugs-request@PostgreSQL.org - avec dans le corps :
-- subscribe - end -- - Une liste de diffusion pour les dveloppeurs est aussi disponible. Pour s'y - inscrire, envoyez un courriel pgsql-hackers-request@PostgreSQL.org - avec dans le corps : -
- subscribe - end -- -
Vous pouvez trouver d'autres listes et informations sur - PostgreSQL sur le site web de PostgreSQL :
- -- -- -
Il y a aussi un canal IRC sur Freenode et EFNet, le canal
- #PostgreSQL. Vous pouvez utiliser la commande Unix
- irc -c '#PostgreSQL' "$USER" irc.phoenix.net ou
- irc -c '#PostgreSQL' "$USER" irc.freenode.net.
Une liste de socits pouvant fournir un support commercial - est disponible sur http://techdocs.postgresql.org/companies.php.
- -La dernire version de PostgreSQL est la version 7.4.5.
- -Nous projetons de sortir une version majeure tous les six huit - mois.
- -Plusieurs manuels, pages de manuel ainsi que des petits exemples de - test sont inclus dans la distribution. Voir le rpertoire - /doc. Vous pouvez aussi accder aux manuels en ligne sur http://www.PostgreSQL.org/docs.
- -Deux livres sur PostgreSQL sont disponibles en ligne sur http://www.PostgreSQL.org/docs/awbook.html - et http://www.commandprompt.com/ppbook/. - Il y a une liste de livres sur PostgreSQL pouvant tre achets sur http://techdocs.PostgreSQL.org/techdocs/bookreviews.php. - Il y a aussi une collection d'articles techniques sur PostgreSQL sur http://techdocs.PostgreSQL.org/.
- -psql possde des commandes \d pratiques montrant des - informations sur les types, oprateurs, fonctions, aggrgats, etc.
- -Notre site web contient encore plus de documentations.
- -PostgreSQL supporte un sous-ensemble tendu de SQL-92. - Voir notre liste TODO - pour les bogues connus, les fonctionnalits manquantes et les - plans pour le futur.
- -Le livre PostgreSQL sur http://www.PostgreSQL.org/docs/awbook.html - enseigne le SQL. Il existe un autre livre PostgreSQL sur http://www.commandprompt.com/ppbook. - Il existe de bons tutoriels sur http://www.intermedia.net/support/sql/sqltut.shtm, - - http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM - et http://sqlcourse.com.
- -Un autre (en anglais uniquement) "Teach Yourself SQL in 21 Days, Second Edition" - se trouve sur http://members.tripod.com/er4ebus/sql/index.htm
- -Nombre de nos utilisateurs aiment The Practical SQL Handbook, - Bowman, Judith S., et al., Addison-Wesley. D'autres aiment The - Complete Reference SQL, Groff et al., McGraw-Hill.
- -Oui, nous manipulons facilement les dates aprs et avant l'an 2000.
- -Tout d'abord, tlchargez les derniers sources et lisez la - documentation pour les dveloppeurs sur notre site web ou bien - dans la distribution. Ensuite, inscrivez-vous aux listes de - diffusion pgsql-hackers et pgsql-patches. Et pour finir, - soumettez des correctifs de grande qualit sur pgsql-patches.
- -Environ une douzaine de personnes ont des droits de modification - sur l'archive CVS de PostgreSQL. Ils ont chacun - soumis tellement de correctifs de qualit qu'il tait devenu - impossible aux dveloppeurs de tenir la cadence et nous avions - confiance dans le qualit des correctifs qu'ils soumettaient.
- -Merci de visiter la page PostgreSQL BugTool sur http://www.PostgreSQL.org/bugs/bugs.php, - qui donne des indications sur la faon de soumettre un rapport de bogue.
- -De mme, vrifiez notre site ftp ftp://ftp.PostgreSQL.org/pub pour - voir s'il existe une version PostgreSQL plus rcente ou des - correctifs.
- -Il y a plusieurs manires de mesurer un logiciel : les fonctionnalits, - les performances, la fiabilit, le support, et le prix.
- -PostgreSQL possde une infrastructure de premire classe depuis - le dbut en 1996. Ceci grce Marc Fournier, qui a cr et gr - cette infrastructure des annes durant.
- -Une infrastructure de qualit est importante pour un projet - open-source. Cela permet d'empcher l'parpillement qui ralentirait - beaucoup l'avancement du projet.
- -Bien sr, cette infrastructure n'est pas donne. Elle requiert - un certain nombre de dpenses mensuelles ou ponctuelles. Si vous - ou votre socit peut donner de l'argent pour soutenir cet effort, - merci de consulter la page web http://store.pgsql.com/shopping/ - et de faire une donation.
- -Bien que la page web mentionne PostgreSQL, Inc, les - contributions sont exclusivement utilises pour soutenir le - projet PostgreSQL et ne soutiennent aucune socit que ce soit. Si - vous le prfrez, vous pouvez aussi envoyer un chque l'adresse - de contact.
-De plus, si vous avez une histoire de succs avec PostgreSQL, - merci de la soumettre notre site d'vanglisation sur - http://advocacy.postgresql.org.
- - - -Il y a deux pilotes ODBC disponibles, PsqlODBC - et OpenLink ODBC.
- -Vous pouvez tlcharger PsqlOBDC depuis - http://gborg.postgresql.org/project/psqlodbc/projdisplay.php.
- -OpenLink ODBC peut tre obtenu depuis http://www.openlinksw.com. Il fonctionne - avec leur logiciel client ODBC standard, vous aurez - donc PostgreSQL ODBC sur toutes les plateformes - client qu'ils supportent (Win, Mac, Unix, VMS).
- -Ils vendront probablement ce produit aux gens qui recherchent - une qualit de support professionnelle mais une version freeware sera - toujours disponible. Merci d'envoyer vos questions postgres95@openlink.co.uk.
- -Une bonne introduction aux pages Web adosss une base de donnes se - trouve http://www.webreview.com
- -Pour l'intgration Web, PHP est une excellente interface. Elle se trouve http://www.php.net.
- -Pour les cas complexes, beaucoup utilisent l'interface Perl et CGI.pm ou mod_perl.
- -Oui, il y a plusieurs interfaces graphiques disponibles pour PostgreSQL, - dont PgAccess - http://www.pgaccess.org), PgAdmin III (http://www.pgadmin.org), - RHDB Admin (http://sources.redhat.com/rhdb/ - et Rekall ( - http://www.thekompany.com/products/rekall/, propritaire). Il y a - aussi PhpPgAdmin ( - http://phppgadmin.sourceforge.net/ ), une interface Web pour - PostgreSQL.
- -Voir http://techdocs.postgresql.org/guides/GUITools pour une liste plus dtaille.
- -La plupart des langages de programmation couramment utiliss ont - une interface pour PostgreSQL. Vrifiez la liste des modules de votre - langage.
- -Les interfaces ci-dessous sont incluses dans la distribution :
- -Interfaces supplmentaires disponibles sur - http://gborg.postgresql.org - dans la section Drivers/Interfaces -
-Il faut spcifier l'option --prefix lors du lancement de configure.
- -Cela peut tre d une varit de problmes mais vrifiez d'abord que - vous avez les extensions System V installes pour votre noyau. PostgreSQL - ncessite le support noyau pour la mmoire partage et les smaphores.
- -Soit vous n'avez pas configur correctement la mmoire partage dans - votre noyau, soit vous devez augmenter la mmoire partage disponible dans - le noyau. Le montant exact dont vous avez besoin dpend de votre - architecture et du nombre de tampons et de processus que vous avez - configur pour postmaster. Pour la plupart des systmes avec un - nombre par dfaut de tampons et de processus, vous aurez besoin d'un minimum - d'environ 1 Mo. Voir le chapitre Administration - du manuel PostgreSQL pour des informations plus dtailles sur la mmoire partage et les smaphores.
- -Si le message d'erreur est IpcSemaphoreCreate: semget failed (No - space left on device) alors votre noyau n'est pas configur avec - suffisamment de smaphores. PostgreSQL a besoin d'un smaphore par processus - serveur potentiel. Une solution provisoire est de lancer postmaster - avec une plus petite limite sur le nombre de processus serveur. Utilisez l'option - -N avec un paramtre infrieur au choix par dfaut de 32. Une - solution permanente est d'augmenter les paramtres - SEMMNS et SEMMNI de votre noyau.
- -Des smaphores inoprantes peuvent aussi provoquer des plantages pendant de gros accs la base de donnes.
- -Si le message d'erreur est autre chose, vous n'avez peut-tre pas du tout le support des - smaphores dans votre noyau. Voir le - chapitre Administration - du manuel PostgreSQL pour des informations plus dtailles sur la mmoire partage et les smaphores.
- -Par dfaut, PostgreSQL autorise seulement les connexions de la machine - locale en utilisant les sockets de domaine Unix ou les connexions TCP/IP. - D'autres machines ne seront pas capables de se connecter sauf si vous modifiez - listen_addresses dans postgresql.conf et activez une authentification base - sur l'hte en modifiant le fichier $PGDATA/pg_hba.conf en accord.
- -Des index acclreront les requtes. La commande - EXPLAIN ANALYZE vous permet de voir comment PostgreSQL traite - votre requte et quels index sont utiliss.
- -Si vous faites beaucoup d'insertions (instruction INSERT), - envisagez de les faire en une fois en utilisant la commande COPY. Ceci - est plus rapide que des commandes INSERTS individuelles. Deuximent, - les requtes qui ne sont pas dans des blocs de transaction BEGIN WORK/COMMIT - sont considrs comme tant dans leur propre transaction. Envisagez de faire - plusieurs instructions dans un seul bloc de transaction. Ceci rduira la - surcharge apporte par les transactions. Aussi, envisagez d'abandonner et - de recrer des index lors de grosses modifications de donnes.
- -Il y a plusieurs options d'optimisations. Vous pouvez dsactiver - fsync() en lanant postmaster avec l'option -o -F. - Ceci empchera les fsync()s d'crire sur disque aprs toute - transaction.
- -Vous pouvez utiliser l'option -B de postmaster pour - augmenter le nombre de tampons de mmoire partage utiliss par les - processus serveurs. Si vous fixez ce paramtre trop haut, - postmaster ne se lancera pas car vous avez dpass la limite de - votre noyau sur la quantit de mmoire partage. Chaque tampon fait 8 Ko et - le choix par dfaut est de 64 tampons.
- -Vous pouvez utiliser l'option serveur -S pour augmenter la - quantit maximale de mmoire utilise par les processus serveurs pour des - tris temporaires. La valeur de -S est mesur en kilooctets et le - choix par dfaut est de 512 (c'est--dire 512 Ko).
- -Vous pouvez utiliser la commande CLUSTER pour regrouper - vos donnes en tables pour correspondre un index. Voir la page de manual - CLUSTER pour plus de dtails.
- -PostgreSQL a plusieurs fonctionalits qui permettent de recueillir des - informations de statut qui peuvent tre utile pour des intentions de - dboguage.
- -D'abord, en lanant configure avec l'option --enable-cassert, - beaucoup d'assert()s surveillent le serveur et arrtent le programme - quand quelque chose d'inattendu arrive.
- -Postmaster et postgres ont tous deux plusieurs options de - dboguage de disponible. D'abord, quand vous lancez postmaster, - vrifiez que vous envoyez les sorties standard et d'erreur dans un fichier - de traces comme :
-- cd /usr/local/pgsql - ./bin/postmaster >server.log 2>&1 & -- -
Ceci va crer un fichier server.log dans le rpertoire racine de - PostgreSQL. Ce fichier contient des informations utiles sur les problmes - ou erreurs rencontrs par le serveur. Postmaster dispose d'une - option -d qui permet de rapporter des informations encore plus - dtailles d'tre rapportes. L'option -d prend un numro qui - spcifie le niveau de dboguage. Faites attention au fait que des valeurs - lves de niveau de dboguage gnerent des fichiers de traces volumineux.
- -Si postmaster ne tourne pas, vous pouvez lancer le serveur - postgres de la ligne de commande et taper votre requte - SQL directement. Ceci est recommand seulement pour - des fonctions de dboguage. Notez qu'un retour chariot termine la requte, - pas un point-virgule. Si vous compilez avec les symboles de dboguage, vous - pouvez utiliser un dbogueur pour voir ce qui se passe. Parce que le serveur - n'a pas t lanc par postmaster, il ne tourne pas dans un environnement - identique et les problmes d'interaction de verrouillage/serveur ne peuvent - tre dupliqus.
- -Si postmaster est en train de tourner, lancez psql dans - une fentre puis trouvez le PID du processus postgres - utilis par psql. Utilisez un dbogueur pour l'attacher au - PID postgres. Vous pouvez mettre un point d'arrt - dans le dbogueur et envoyez des requtes de psql. Si vous dboguez - le dmarrage de postgres, vous pouvez mettre PGOPTIONS="-W n", puis - lancez psql. Ceci va retarder le dmarrage de n secondes - pour que vous puissiez attacher un dbogueur au processus, fixer des points - d'arrt et continuer la squence de dmarrage.
- -Le programme postgres a les options -s, -A et -t - qui peuvent tre utile pour des mesures de dboguage et de performance.
- -Vous pouvez compiler avec les options de performance pour voir quelles - fonctions prennent du temps d'excution. Les fichiers de gestion du serveur - seront dposs dans le rpertoire pgsql/data/base/nom_db. Les - fichiers de gestion clients seront mis dans le rpertoire actuel du client. - Linux requiert une compilation avec -DLINUX_PROFILE pour une - meilleure gestion.
- -Vous pouvez augmenter la limite de postmaster sur le nombre de - processus serveur concurrents qu'il peut lancer.
- -La limite par dfaut est de 32 processus. Vous pouvez l'augmenter en - relanant postmaster avec une valeur -N approprie ou - en modifiant postgresql.conf.
- -Tenez compte du fait que si vous fixez -N plus grand que 32, vous - devez aussi augmenter -B au-dela de sa valeur par dfaut 64 ; - -B doit valoir au moins deux fois -N et probablement plus pour - une meilleure performance. Pour de grand nombres de processus serveurs vous - aurez probablement aussi augmenter plusieurs parametres de configuration du - noyau Unix. Les choses a vrifier incluent la taille maximale des blocs de - mmoire partage, SHMMAX ; le nombre maximal de - smaphores, SEMMNS et SEMMNI ; le - nombre maximal de processus, NPROC ; le nombre maximal - de processus par utilisateur, MAXUPRC ; et le nombre - maximal de fichiers ouverts, NFILE et NINODE. - La raison pour laquelle PostgreSQL a une limite sur le nombre de processus - serveurs autoriss est pour que votre systme ne tombe pas court de - ressources.
- -Ce rpertoire contient des fichiers temporaires gnrs par le moteur de - requte. Par exemple, si un tri doit tre fait pour satisfaire un - ORDER BY et que ce tri requiert plus de place que le paramtre - -S du serveur n'autorise, alors des fichiers temporaires seront crs - pour contenir les donnes ncessaires.
- -Les fichiers temporaires sont d'habitude effacs automatiquement mais - peuvent rester si un serveur s'arrte brutalement pendant un tri. Un arrt - et un redmarrage de postmaster effacera les fichiers dans ces - rpertoires.
- -L'quipe PostgreSQL ne fait que des changements mineurs entre des - versions mineurs, donc mettre jour de 7.2 vers 7.2.1 ne ncessitera pas - de sauvegarde et de restauration. Par contre, les sorties majeures - (c'est--dire de 7.2 vers 7.3) changent souvent le format interne des tables - systmes et des fichiers de donnes. Ces modifications sont souvent - complexes alors nous ne gardons pas de compatibilit descendante pour les - fichiers de donnes. Une sauvegarde exportera les donnes dans un format - gnrique qui peut ensuite tre charg dans le nouveau format interne.
- -Dans les sorties o le format sur disque ne change pas, le script - pg_upgrade peut tre utilis pour mettre jour sans - sauvegarde/restauration. Les notes de sorties prcisent si pg_upgrade - est disponible pour la sortie.
- -Comme le matriel PC est compatible en grosse partie, les gens ont - tendance croire que tous les matriels PC sont de mme qualit. Ce n'est - pas le cas. La RAM ECC, le SCSI et les cartes-mre de qualit sont plus - fiables et ont de meilleurs performances qu'un matriel moins coteux. - PostgreSQL fonctionnera sur peu prs tout matriel mais si la fiabilit et - la performance sont importantes pour vous, il est rus de bien considrer - les options matrielles. Nos listes de diffusion peuvent tre utilises pour - discuter des options matriels.
- -Voir la page DECLARE du manuel pour une description.
- -Voir la page FETCH du manuel ou utiliser - SELECT ... LIMIT....
- -Il se peut que l'intgralit de la requte doive tre value, - mme si vous voulez seulement les premires lignes. Envisagez - d'utiliser une requte avec une clause ORDER - BY. S'il existe un index correspondant l'ORDER - BY, PostgreSQL peut n'valuer que les premires lignes, sinon - l'intgralit de la requte peut tre value, jusqu' gnrer les lignes - dsires.
- -Pour faire un SELECT sur une ligne alatoire :
-- SELECT colonne - FROM table - ORDER BY random() - LIMIT 1; -- -
Utilisez la commande \dt pour voir les tables dans psql. Pour - une liste complte de commandes l'intrieur de psql, vous pouvez utiliser - \?. Autrement, vous pouvez lire le code source de psql dans le fichier - pgsql/src/bin/psql/describe.c. Il contient des commandes - SQL qui gnrent le contenu des commandes anti-slash de - psql. Vous pouvez aussi lancer psql avec l'option - -E, afin qu'il imprime les requtes qu'il utilise pour excuter - les commandes que vous lui passez. PostgreSQL fournit aussi une interface - d'informations sur le schma compatible avec SQLi que vous pouvez - interroger des informations sur la base de donnes.
- -La fonction DROP COLUMN a t ajoute dans la version 7.3 - avec ALTER TABLE DROP COLUMN. Pour les versions prcdentes, - vous pouvez faire :
-- BEGIN; - LOCK TABLE ancienne_table; - SELECT ... -- slectionnez toutes les colonnes sauf celle supprimer - INTO TABLE nouvelle_table - FROM ancienne_table; - DROP TABLE ancienne_table; - ALTER TABLE nouvelle_table RENAME TO ancienne_table; - COMMIT; -- -
Pour changer le type de donnes d'une colonne, faites :
- -- BEGIN; - ALTER TABLE table ADD COLUMN nouvelle_colonne nouveau_type_de_donnees; - UPDATE table SET nouvelle_colonne = CAST(ancienne_colonne AS nouveau_type_de_donnees); - ALTER TABLE table DROP COLUMN ancienne_colonne; - COMMIT; -- -
Aprs, vous pouvez faire VACUUM FULL tab pour rcuprer l'espace - disque utilis par les lignes expires.
- -Les limites sont :
-- Taille maximum pour une base de donnes illimite (il existe des bases de 32 To) - Taille maximum pour une table 32 To - Taille maximum pour une ligne 1,6 To - Taille maximum pour un champ 1 Go - Nombre maximum de lignes dans une table illimit - Nombre maximum de colonnes dans une table 250-1600, selon le type de colonnes - Nombre maximum d'index sur une table illimit -- -
Bien sr, ces valeurs ne sont pas vraiment illimite, elles sont limites - par l'espace disque disponible, ainsi que par l'espace de mmoire et de swap. - Les performances peuvent se dgrader si ces valeurs sont inhabituellement - grandes.
- -La taille maximum des tables (32 To) ne ncessite pas que le systme - d'exploitation supporte les grands fichiers. Les grandes tables sont stockes - sous forme de fichiers multiples de 1 Go, donc les limites de taille du - systme de fichier ne sont pas importantes.
- -La taille maximum des tables et le nombre maximum de colonnes peuvent - tre quadripls, si la taille des blocs par dfaut est augmente 32 Ko.
- -Une base de donnes PostgreSQL peut utiliser jusqu' cinq fois - l'espace ncessaire pour stocker les donnes d'un fichier texte.
- -A titre d'exemple, considrez un fichier de 100 000 lignes, comportant - un entier et une chane de description sur chaque ligne. Supposons que la - chane soit longue en moyenne de 20 octets. Le fichier texte serait de 2,8 Mo. - La taille du fichier d'une base de donnes PostgreSQL peut tre - estime 6,4 Mo :
-- 32 octets: chaque ligne (approximation) - 24 octets: un champ 'entier' et un champ 'texte' - + 4 octets: pointeur vers le tuple sur la page - ---------------------------------------- - 60 octets par ligne - - La taille des pages de donnes dans PostgreSQL est de 8192 octets (8 KO), donc : - - 8192 octets par page - ---------------------- = 136 lignes par page de base de donnes (arrondi l'entier infrieur) - 60 octets par ligne - - 100000 lignes de donnes - ------------------------- = 735 pages de base de donnes (arrondi l'entier suprieur) - 128 lignes par page - -735 pages de base de donnes * 8192 octets par page = 6 021 120 octets (6,4 Mo) -- -
Les index utilisent moins d'espace, mais ils contiennent les donnes indexes, - ils peuvent donc galement tre grands.
- -Les NULL sont stocks sous forme de bitmap, aussi - utilisent-ils trs peu d'espace.
- -psql dispose de plusieurs commandes commenant par un anti-slash - pour retrouver ces informations. Utilisez \? pour les connatre. Il existe - aussi des tables systmes, qui commencent par pg_ et qui les - dcrivent galement. Aussi, psql -l liste toutes les bases de - donnes.
- -Essayez galement le fichier pgsql/src/tutorial/syscat.source. Il - illustre un grand nombre de commandes SELECT ncessaires pour - rcuprer l'information des tables systme de la base de donnes.
- -Les index ne sont pas automatiquement utiliss par chaque requte. Ils - sont utiliss uniquement si la table est plus grande qu'une certaine taille, - et si la requte slectionne seulement un faible pourcentage des lignes de la - table. Ceci est d au fait qu'un accs disque alatoire caus par un parcours - d'index peut tre plus lent qu'une simple lecture de la table, ou parcours - squentiel
- -Pour dterminer si un index devrait tre utilis, PostgreSQL a besoin - des statistiques de la table. Ces statistiques sont collectes en lanant - VACUUM ANALYZE ou simplement ANALYZE. - Avec les statistiques, l'optimiseur sait combien de lignes se trouvent - dans la table et peut mieux dterminer s'il faut utiliser l'index. - Les statistiques sont galement utiles pour dterminer l'ordre optimal - des oprations de jointure. La collecte des statistiques devrait tre - effectue rgulirement lorsque le contenu de la table change.
- -Les index ne sont normalement pas utiliss pour les clauses ORDER BY - ou pour les jointures. Un parcours squentiel suivi d'un tri explicite est - habituellement plus rapide qu'un parcours d'index pour une table importante. - Toutefois, LIMIT combin avec ORDER BY - utilisera souvent un index parce que seulement une petite partie de la table est - renvoye. En fait, bien que MAX() et MIN() n'utilisent pas les index, - il est possible de retrouver ces valeurs en utilisant un index avec - ORDER BY et LIMIT :
- -- SELECT colonne - FROM table - ORDER BY colonne [ DESC ] - LIMIT 1; -- -
Si vous pensez que l'optimiseur choisit par erreur un parcours sequentiel,
- utilisez SET enable_seqscan TO 'off' et
- lancez des tests pour voir si le parcours d'index est effectivement plus rapide.
Lorsque vous utilisez des caractres joker tels que LIKE ou - ~, les index peuvent seulement tre utiliss dans certaines circonstances :
-Dans les versions antrieures la 8.0, les indexs ne peuvent souvent - pas tre utiliss sauf si les types de donnes correspondent exactement au - type de la colonne de l'index. Ceci est particulirement vrai pour les - index de colonnes de type int2, int8 et numeric.
- -Voir la page EXPLAIN du manuel.
- -Un index R-tree est utilis pour l'indexation des donnes spatiales. Un - index de hachage ne permet pas les recherches par plage. Un index B-tree peut - seulement faire des recherches sur une dimension. Les index R-tree - peuvent traiter des donnes multi-dimensionnelles. Par exemple, si un index - R-tree peut tre construit sur un attribut de type point, - le systme peut plus efficacement grer les requtes du type - "Slection de tous les points d'un rectangle".
- -L'article de rfrence qui dcrit le systme R-tree original est :
- -Guttman, A. "R-trees: A Dynamic Index Structure for Spatial - Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt - of Data, 45-57.
- -Vous pouvez galement trouver ce papier dans le livre de Stonebraker - "Readings in Database Systems".
- -Les index R-tree intgrs peuvent prendre en charge les polygnes et les botes. - En thorie, les R-trees peuvent tre tendus un plus grand nombre de dimensions. - En pratique, l'extension des R-trees requiert pas mal de travail et nous - n'avons pour le moment aucune documentation sur la faon de procder.
- -Le module GEQO (acronyme de GEnetic Query - Optimizer) acclre l'optimisation des requtes lors de jointures de - nombreuses tables par un algorithme gntique (GA). Il permet la - gestion des grosses requtes de jointures en utilisant une recherche non - exhaustive.
- -L'oprateur ~ ralise des recherches d'expressions rationnelles - et ~* le fait sans tenir compte de la casse. La variante de - LIKE non sensible la casse est - ILIKE.
- -Des comparaisons d'galit non sensibles la casse sont habituellement - exprimes de cette faon :
-- SELECT * - FROM table - WHERE lower(colonne) = 'abc'; -- -
Ceci n'utilisera pas un index standard. Nanmoins, si vous crez un index - fonctionnel, celui-ci sera utilis :
-- CREATE INDEX tableindex ON table (lower(colonne)); -- -
Il vous suffit de tester la colonne avec IS NULL ou IS - NOT NULL.
- --Type Nom interne Notes --------------------------------------------------- -VARCHAR(n) varchar n spcifie la taille maximum, sans remplissage -CHAR(n) bpchar des espaces sont ajouts pour obtenir la - longueur fixe spcifie -TEXT text pas de limite suprieure pour la taille -BYTEA bytea tableau d'octets (accepte les octets nuls) -"char" char un caractre -- -
Vous verrez le nom interne en examinant les catalogues systme et dans - quelques messages d'erreur.
- -Les quatres premiers types du dessus sont des types "varlena" - (c'est--dire que les quatre premiers octets correspondent la taille, - suivi des donnes). Donc, l'espace rellement utilis est lgrement plus - grand que la taille dclare. Nanmoins, ces types de donnes sont aussi - sujet la compression ou un enregistrement en dehors de la table avec - TOAST, donc l'espace occup sur disque pourrait aussi tre - moindre que ce qu'on pourrait attendre.
- -VARCHAR(n) est bien mieux pour enregistrer des chanes de - longueurs variables tout en limitant la taille de cette chane. - TEXT est utile pour les chanes de longueur illimite, avec - malgr tout un maximum de 1 Go.
- -CHAR(n) est intressant pour stocker des chanes de taille - identique. CHAR(n) complte avec des espaces pour arriver - la taille spcifie alors que VARCHAR(n) n'enregistre que les - caractres donns. BYTEA sert stocker des donnes binaires, - particulirement les donnes incluant des octets NULL. Tous - les types dcrits ici ont des performances similaires.
- -PostgreSQL supporte un type de donnes SERIAL. Il cre - automatiquement une squence. Par exemple, - ceci :
-- CREATE TABLE personne ( - id SERIAL, - nom TEXT - ); -- - est automatiquement traduit en ceci : -
- CREATE SEQUENCE personne_id_seq;
- CREATE TABLE personne (
- id INT4 NOT NULL DEFAULT nextval('personne_id_seq'),
- nom TEXT
- );
-
-
- Voir la page man de create_sequence pour plus d'informations
- sur les squences. Vous pouvez aussi utiliser le champ OID de chaque
- ligne comme valeur unique. Nanmoins, si vous avez besoin de sauvegarder
- puis recharger la base de donnes, vous devrez utiliser l'option
- -o ou l'option COPY WITH OIDS de
- pg_dump pour conserver les OIDs.
-
- Une approche pour rcuprer la prochaine valeur SERIAL - partir de l'objet squence est d'utiliser la fonction nextval() - avant l'insertion et de l'insrer ensuite explicitement. En utilisant - la table d'exemple de la section 4.15.1, un exemple - dans un pseudo-langage ressemblerait ceci :
-
- nouvelle_id = execute("SELECT nextval('personne_id_seq')");
- execute("INSERT INTO personne (id, nom) VALUES (nouvelle_id, 'Blaise Pascal')");
-
-
- Vous pourriez ensuite utiliser la nouvelle valeur stocke dans
- nouvelle_id avec d'autres requtes (c'est--dire en tant que
- cl trangre de la table personne). Notez que le nom de la
- SEQUENCE automatiquement cre sera
- <table>_<colonneserial>_seq, o
- table et colonneserial sont les noms respectifs de votre table
- et de votre colonne SERIAL.
-
- Autrement, vous pouvez rcuprer la valeur SERIAL affecte - avec la fonction currval() aprs qu'elle ait t insre par - dfaut, c'est--dire,
-
- execute("INSERT INTO personne (nom) VALUES ('Blaise Pascal')");
- nouvelle_id = execute("SELECT currval('personne_id_seq')");
-
-
- Enfin, vous pouvez utiliser l'OID renvoy
- par l'instruction INSERT pour rcuprer la valeur par dfaut
- bien que cela soit l'appoche la moins portable et la valeur de l'OID se
- rinitialisera aux environs de quatre milliards. En Perl, avec DBI et le
- module DBD:Pg d'Edmund Mergl, l'ancienne valeur est disponible via
- $sth->{pg_oid_status} aprs un $sth->execute().
-
- Non. currval() renvoie la valeur actuelle affecte par votre - processus, et non pas par tous les utilisateurs.
- -Pour amliorer les accs concurrents, les valeurs de squences sont - donnes aux transactions qui en ont besoin et ne sont pas bloques jusqu' - la fin de la transaction. Ceci cre des trous dans le numrotage pour les - transactions annules.
- -Les OID sont la rponse de PostgreSQL aux identifiants de - lignes uniques. Chaque ligne cre dans PostgreSQL obtient un - OID unique. Tous les OID gnrs pendant - initdb sont infrieurs 16384 (voir include/access/transam.h). - Tous les OID crs par un utilisateur sont suprieurs ou - gaux ceci. Par dfaut, tous ces OID sont uniques non - seulement dans une table ou une base mais unique l'intrieur d'une - installation PostgreSQL entire.
- -PostgreSQL utilise les OID dans ses tables systme interne - pour lier les lignes entre tables. Ces OID peuvent tre - utiliss pour identifier des lignes utilisateurs spcifiques et utiliss dans - des jointures. Il est recommand que vous utilisiez le type de colonne - OID pour stocker des valeurs OID. - Vous pouvez crer un index sur le champ OID pour un accs - plus rapide.
- -Les OID sont attribus pour toute ligne d'un endroit - central qui est utilis par toutes les bases de donnes. Si vous voulez - changer l'OID en quelque chose d'autre ou si vous voulez - faire une copie de la table avec les OID originaux, il - n'y a pas de raisons pour ne pas le faire :
-- CREATE TABLE nouvelle_table (macolonne int); - SELECT oid AS ancienne_oid, macolonne INTO table_temporaire FROM ancienne_table; - COPY table_temporaire FROM '/tmp/tablepg'; - COPY nouvelle_table WITH OIDS FROM '/tmp/tablepg'; - DROP TABLE table_temporaire; -- -
Les OID sont stocks en tant qu'entiers de quatre octets - et dborderont quatre milliards. Personne n'a jamais rapport un tel cas - et nous avons prvu de retirer la limite avant que cela ne se produise.
- -Les TIDs sont utiliss pour identifier des lignes - physiques spcifiques avec des valeurs de bloc et dcalage. Les - TID changent aprs que les lignes aient t modifis ou - rechargs. Ils sont utiliss par des entres d'index pour pointer vers des - lignes physiques.
- -Une partie du code source et de l'ancienne documentation utilisent des - termes dont l'usage est plus commun. Voici quelques exemples :
- -Une liste des termes gnraux pour le domaine des bases de donnes est - disponible sur : http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary/glossary.html
- -Vous manquez probablement de mmoire virtuelle sur votre systme ou votre - noyau a une limite assez basse pour certaines ressources. Essayez ceci avant - de lancer postmaster :
-- ulimit -d 262144 - limit datasize 256m -- - Suivant votre shell, seul un d'eux pourrait russir mais cela configurera - d'une faon plus importante la taille du segment de donnes de votre - processus. Cette commande s'applique au processus actuel et tous les - processus lanc par celui-ci. Si vous avez des problmes avec le client - SQL parce que le processus serveur renvoie trop de donnes, - essayez a avant de lancer le client. - -
A partir de psql, tapez SELECT version();
Vous avez besoin de placer BEGIN WORK et COMMIT
- autour de chaque utilisateur de gros objets, c'est--dire pour entourer
- lo_open ... lo_close.
Actuellement, PostgreSQL force cette rgle en fermant les gros objets - lors de la transaction. Donc, le premier essai d'oprations sur ces objets, - fonctionnant habituellement (au moins la plupart du temps) aura un - invalid large obj descriptor. Donc le code, auparavant fonctionnel - (au moins la plupart du temps), gnrera maintenant un message d'erreur si - vous n'utilisez pas de transaction.
- -Si vous utilisez une interface client interface comme
- ODBC, vous aurez peut-tre besoin de lancer
- auto-commit off.
Utilisez CURRENT_TIMESTAMP:
-
-CREATE TABLE test (x int, heuremodif timestamp DEFAULT CURRENT_TIMESTAMP );
-
-
-
- IN sont-elles si lentes ?Dans les versions prcdant la 7.4, les sous-requtes ont t jointes avec
- des jointures externes en parcourant squentiellement le rsultat de la
- sous-requte pour chaque ligne de la requte externe. Si la sous-requte
- renvoit quelques lignes et que la requte externe en renvoit plein,
- IN sera plus rapide. Pour acclrer les autres
- requtes, remplacez IN avec EXISTS :
SELECT * - FROM table - WHERE colonne IN (SELECT souscolonne FROM soustable); -- to: -
SELECT * - FROM table - WHERE EXISTS (SELECT souscolonne FROM soustable WHERE souscolonne = colonne); -- - Pour que ceci soit rapide,
souscolonne doit tre une colonne
- indexe.
-
- A partir de la version 7.4, IN utilise actuellement les mmes
- techniques sophistiques de jointures comme des requtes normales et est
- prfr l'utilisation de EXISTS.
PostgreSQL supporte les jointures externes en utilisant la syntaxe SQL - standard. Voici deux exemples :
-- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -- or -
- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- -
Ces requtes identiques joignent t1.col t2.col et renvoient toute - colonne non jointe de t1 (celles sans correspondance dans t2). Une jointure - droite (RIGHT join) ajoutera les lignes non jointes de t2. - Une jointure complte (FULL join) renverra les lignes - correspondantes ainsi que les lignes non jointes de t1 et t2. Le mot cl - OUTER est optionnelle et assum dans le cas de jointure - LEFT, RIGHT et FULL. Les - jointures ordinaires sont appeles des jointures INNER.
- -Lors des prcdentes versions, les jointures externes peuvent tre
- simules en utilisant UNION et NOT IN. Par
- exemple, lors d'une jointure de tab1 et tab2, la requte
- suivante ralise une jointure externe, outer, des deux tables :
-
-
- SELECT tab1.col1, tab2.col2 - FROM tab1, tab2 - WHERE tab1.col1 = tab2.col1 - UNION ALL - SELECT tab1.col1, NULL - FROM tab1 - WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2) - ORDER BY col1 -- -
Il n'existe pas de moyens de lancer des requtes sur une autre base que - la courante. Comme PostgreSQL charge des catalogues systmes spcifiques - la base de donnes, sa raction aux requtes inter-base de donnes est - incertaine.
- -contrib/dblink permet les requtes entre bases de donnes en - utilisant des fonctions. Bien sr un client peut raliser des connexions - simultanes plusieurs bases de donnes et joindre les rsultats du ct - client.
- -A partir de la 7.3, vous pouvez facilement renvoyer plusieurs lignes ou - colonnes partir d'une fonction, - - http://techdocs.postgresql.org/guides/SetReturningFunctions.
- -PL/PgSQL cache le contenu des fonctions et un effet de bord malheureux est - que si une fonction PL/PgSQL accde une table temporaire, que cette table - est ensuite supprime et recre, et que la fonction est appele de nouveau, - la fonction chouera car le contenu de la fonction cache pointera toujours - vers l'ancienne table temporaire. La solution revient utiliser - EXECUTE pour l'accs aux tables temporaires avec PL/PgSQL. - Ceci obligera l'analyse de la requte chaque fois.
- -Il peut y avoir plusieurs raisons. Essayez tout d'abord votre fonction utilisateur - dans un programme de test.
- -Envoyez vos extensions la liste de diffusion pgsql-hackers, - elles atterriront ventuellement dans le sous-rpertoire contrib/.
- -Dans les versions de PostgreSQL partir de 7.3, les fonctions qui - renvoient une table sont totalement supportes en C, PL/PgSQL, et SQL. Voir - le Guide du Programmeur pour plus d'information. Un exemple de fonction - renvoyant une table dfinie en C se trouve - contrib/tablefunc.
- -Les Makefiles n'ont pas les dpendances adquates pour les - fichiers d'en-tte. Il vous faut faire make clean puis un autre - make. Si vous utilisez GCC, vous pouvez utiliser - l'option --enable-depend de configure pour que le - compilateur calcule les dpendances automatiquement.
- - - diff --git a/doc/src/FAQ/FAQ_german.html b/doc/src/FAQ/FAQ_german.html deleted file mode 100644 index bd3f8689564..00000000000 --- a/doc/src/FAQ/FAQ_german.html +++ /dev/null @@ -1,1067 +0,0 @@ - - - - -Current maintainer: Bruce Momjian (bruce@momjian.us).
- -Deutsche Übersetzung von Ian Barwick (barwick@gmail.com).
- -Letzte Aktualisierung der deutschen Übersetzung: Fr., den 19.10.2007, 17:00 MEZ
- -Die aktuellste Version dieses Dokuments liegt auf der PostgreSQL-Website:
-Übersetzungen dieses Dokuments in anderen Sprachen sowie plattform- - spezifische FAQs können unter - http://www.postgresql.org/docs/faq/ - eingesehen werden.
- -Die (englische) Aussprache ist "Post-Gres-Q-L". Im allgemeinen - Sprachgebrauch hat sich die Kurzform "Postgres" auch durchgesetzt. - (Für diejenigen, die es interessiert: eine MP3-Datei mit der amerikanischen - Aussprache befindet sich hier: - http://www.postgresql.org/files/postgresql.mp3 -
- -PostgreSQL ist ein objektrelationales Datenbanksystem, das die - Vorzüge von kommerziellen Datenbanksystemen mit zukunftsweisenden - Innovationen kombiniert. PostgreSQL ist freie Software und dessen - kompletter Quellcode ist öffentlich verfügbar.
- -Die PostgreSQL-Entwicklung wird von einem Team von meist freiwilligen - Entwicklern durchgeführt. - Dieses Team ist für die Gesamtentwicklung von PostgreSQL - verantwortlich. Es handelt sich um ein Gemeinschaftsprojekt, das nicht - von einer bestimmten Firma kontrolliert wird. Lesen Sie die Entwickler-FAQ: - http://www.postgresql.org/docs/faqs.FAQ_DEV.html - wenn Sie an einer Mitarbeit interessiert sind.
- - -Falls Sie nach dem Namen eines etwaigen Inhabers bzw. nach einem - allmächtigen Zentralkommittee suchen - sparen Sie sich die Mühe, sowas - existiert gar nicht. Es gibt zwar das "Core Committee" sowie Entwickler, - die CVS-Schreibberechtigung haben, jedoch haben diese Gruppen eher nur eine - administrative Rolle. Das Projekt wird durch die Community gesteuert, die - aus den Entwicklern sowie natürlich auch den Nutzern besteht - jeder - kann daran teilnehmen. (Lesen Sie die Entwickler-FAQ: - http://www.postgresql.org/docs/faqs.FAQ_DEV.html - wenn Sie an der PostgreSQL-Entwicklung teilnehmen möchten).
- -PostgreSQL wird unter der klassischen BSD-Lizenz herausgegeben. Im Grunde - genommen erlaubt diese den Nutzern, beliebig mit dem Code umzugehen, - auch der Weiterverkauf von Binärversionen ohne Quellcode ist erlaubt. - Die einzige Einschränkung besteht darin, dass PostgreSQL auf keinen Fall - für etwaige Probleme mit der Software haftet. Außerdem muß der Copyright- - Text in allen Kopien der Software enthalten sein. Dies ist der Originaltext - der BSD-Lizenz:
- -PostgreSQL Data Base Management System
- -Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-6 Regents of the University of California
- -Permission to use, copy, modify, and distribute this software - and its documentation for any purpose, without fee, and without a - written agreement is hereby granted, provided that the above - copyright notice and this paragraph and the following two - paragraphs appear in all copies.
- -IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL - DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS - SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF - CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- -THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE - SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE - UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, - SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- -Es gilt die Copyright-Klausel im Original!
- -Normalerweise kann PostgreSQL auf jeder modernen UNIX-kompatiblen - Plattform eingesetzt werden. Diejenigen Plattformen, die bei der - jeweiligen Versionsfreigabe getestet wurden, sind in den - Installationsanleitungen aufgelistet.
- -PostgreSQL läuft auch auf Microsoft NT-basierten Betriebssystemen - wie Windows 2000 SP4, XP und Server 2003. Ein vorgefertigtes Installationspaket - kann von http://pgfoundry.org/projects/pginstaller heruntergeladen werden. - DOS-basierte Windows-Versionen (Win95, Win98, WinMe) können PostgreSQL nur mit - Hilfe der Cygwin-Umgebung ausführen.
- -Eine Portierung für Novell Netware 6 gibt es unter http://forge.novell.com sowie eine OS/2 (eComStation) version unter - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F.
- -Per Web-Browser hier: http://www.postgresql.org/ftp/ - und per FTP hier: ftp://ftp.postgresql.org/pub/.
- -Die neueste Version von PostgreSQL ist 8.2.5.
- -Die Freigabe einer neuen Hauptversion erfolgt in der Regel jährlich, kleinere - Korrekturversionen alle paar Monaten.
- - -Die PostgreSQL-Community bietet Unterstützung per Mailing-Liste. Die Web-Seite - http://www.postgresql.org/community/lists/ bietet einen Überblick. - Die Listen general und bugs bieten einen guten Einstieg.
- -Eine deutschsprachige Mailing-Liste gibt es hier: - http://archives.postgresql.org/pgsql-de-allgemein/.
- -Der wichtigsten IRC-Channel ist #postgresql auf Freenode - (irc.freenode.net). Unter UNIX/Linux können Sie mit z.B. - irc -c '#postgresql' "$USER" irc.freenode.net. - daran teilnehmen. Auf Freenode gibt es einen spanischsprachigen Channel - #postgresql-es, einen französischen, #postgresqlfr sowie einen brasilianischen, #postgresql-br . - Es gibt außerdem einen PostgreSQL-Channel bei EFNet.
- -Eine Liste von Unternehmen, die Support für PostgreSQL auf kommerzieller - Basis leisten, kann unter - http://www.postgresql.org/support/professional_support - eingesehen werden.
- - -Nutzen Sie das Formular unter http://www.postgresql.org/support/submitbug. - Schauen Sie aber vorher unter ftp://ftp.postgresql.org/pub/ nach, - ob es mittlerweile eine neuere PostgreSQL-Version gibt, in der der Fehler behoben wurde.
- -Bugs, die über das Formular bzw. eine der Mailing-Listen bekanntgegeben wurden, - erhalten typischerweise einer der folgenden Reaktionen:
- -PostgreSQL unterstützt eine erweiterte Teilmenge von SQL:2003. Siehe - unsere TODO-Liste unter http://www.postgresql.org/docs/faqs.TODO.html für eine Auflistung - der bekannten Bugs, fehlenden Features und zukünftigen Pläne.
- -Eine Anfrage nach einem neuen Feature führt normalerweise zu einer der - folgenden Antworten:
-PostgreSQL verwendet kein Bugtracking-System, da es sich als effizienter - erwiesen hat, E-Mails direkt zu beantworten und die TODO-Liste - aktuell zu halten. In der Praxis werden Bugs sehr schnell beseitigt, und - diejenigen Bugs, die Auswirkungen auf eine große Anzahl von Nutzern haben, - werden meist kurzfristig korrigiert. Der einzige Überblick über alle Änderungen, - Verbesserungen und Korrekturen in einer PostgreSQL-Version befindet sich in - den CVS-Log-Meldungen. - Auch die Release-Notes listen nicht jede Änderung in der Software auf.
- -PostgreSQL bietet umfangreiche Dokumentation, darunter ein großes - Handbuch, man-Pages und einige kleine Testprogramme. Siehe das /doc- - Verzeichnis. Ausserdem sind alle Handbücher online unter http://www.postgresql.org/docs/ - verfügbar.
- -Zwei Bücher zu PostgreSQL sind online verfügbar unter - http://www.postgresql.org/docs/books/awbook.html und - http://www.commandprompt.com/ppbook/ .
- -Eine Liste lieferbarer PostgreSQL-Bücher befindet sich unter - http://www.postgresql.org/docs/books - Diverse technische Artikel befinden sich unter - http://www.postgresql.org/docs/techdocs .
- -psql hat einige nützliche \d-Befehle, um Informationen über Typen, - Operatoren, Funktionen, Aggregate, usw. zu zeigen.
- -Die PostgreSQL-Website enthält noch mehr Dokumentation.
- - -Die oben erwähnten PostgreSQL-spezifische Bücher bieten einen guten Einstieg. - Viele PostgreSQL-Anwender mögen "The Practical SQL Handbook" (Bowman - et al., Addison Wesley). Andere dagegen mögen "The Complete Reference SQL" - (Groff et al., McGraw-Hill).
- -Es gibt ausserdem einige nützliche Online-Tutorials:
-Lesen Sie in der Entwickler-FAQ unter http://www.postgresql.org/docs/faqs.FAQ_DEV.html nach. - -
Es gibt verschiedene Methoden, Software zu messen: Eigenschaften, - Performanz, Zuverlässigkeit, Support und Preis.
- -PostgreSQL besitzt die meisten Eigenschaften - wie Transaktionen, - Unterabfragen (Subqueries), Trigger, Views, referenzielle Integrität bei Fremdschlüsseln und verfeinertes Locking - - die bei großen kommerziellen DBMS vorhanden sind. Es bietet außerdem - einige anderen Eigenschaften, die diese nicht immer haben, wie - benutzerbestimmte Typen, Vererbung, Regeln, und die - Multi-Versionen-Steuerung zum Verringern konkurrierender Locks.
-Die Performanz von PostgreSQL ist mit der von kommerziellen - und anderen Open-Source-Datenbanken vergleichbar. In manchen - Bereichen ist es schneller, in anderen langsamer. In der Regel - beträgt der Unterschied +/-10%.
-Es ist selbstredend, dass ein DBMS wertlos ist, wenn es nicht - zuverlässig arbeitet. Daher bemühen wir uns, nur streng geprüften und - beständigen Code freizugeben, der nur ein Minimum an Programmfehlern - aufweist. Jede Freigabe hat mindestens einen Monat Betatest-Phase - hinter sich, und unsere Freigabehistorie beweist, dass wir stabile und - solide Versionen freigeben, die im Produktionsbetrieb genutzt werden - können. Wir glauben, dass wir im Vergleich mit anderer - Datenbanksoftware vorteilhaft dastehen.
-Unsere Mailinglisten bieten die Möglichkeit, gemeinsam mit einer - großen Gruppe von Entwicklern und Benutzern mögliche Probleme - zu lösen. Wir können nicht immer eine Fehlerbehebung - garantieren, kommerzielle DBMS tun dies aber auch nicht. - Der direkte Kontakt zur Entwickler- und Benutzergemeinschaft und der - Zugriff auf die Handbücher und den Quellcode ermöglicht einen - im Vergleich zu anderen DBMS höherwertigeren Support. Es gibt jedoch auch - Anbieter von kommerziellen Support-Leistungen (siehe FAQ-Punkt 1.7).
-PostgreSQL ist frei verfügbar, sowohl für die kommerzielle wie - auch für die nicht-kommerzielle Nutzung. Sie können den PostgreSQL-Code - ohne Einschränkungen (außer denjenigen, die in der oben angegebene - BSD-artigen Lizenz erwähnt werden) in Ihr Produkt integrieren.
-Änderungen bei der US-Sommerzeit sind ab PostgreSQL Version 8.0.4 - berücksichtigt. Änderungen in Canada und Western Australia sind ab 8.0.10 - bzw. 8.1.6 berücksichtigt. PostgreSQL-Versionen vor 8.0 nutzen die - Zeitzonendatenbank des Betriebssystems, um die Sommerzeit zu berechnen.
- -Die PostgreSQL-Installation stellt nur Schnittstellen für C und
- Embedded C bereit. Alle weitere Schnittstellen sind unabhängige
- Projekte, die einzeln heruntergeladen werden werden müssen. Diese Trennung
- ermöglicht individuelle Entwickler-Teams und Entwicklungszyklen für die
- jeweiligen Projekte.
Einige Programmiersprachen wie PHP haben eine PostgreSQL-
- Schnittstelle bereits eingebaut. Schnittstellen für Sprachen wie Perl, TCL,
- Python und viele anderen sind unter http://gborg.postgresql.org
- im Bereich Drivers/Interfaces verfügbar sowie per Internet-Suche.
Eine nette Einführung zu datenbank-gestützten Webseiten kann unter - http://www.webreview.com (engl.) eingesehen werden.
- -Für die Web-Integration ist PHP eine ausgezeichnete Schnittstelle. - PHP gibt es bei http://www.php.net
- -Für komplexere Aufgaben bietet sich die Perl-Schnittstelle mit CGI.pm - oder mod_perl.
- -Es gibt eine große Anzahl von GUI-Programmen für PostgreSQL - - sowohl kommerziell als auch Open-Source. Eine ausführliche Liste - befindet sich unter http://www.postgresql.org/docs/techdocs.54 .
- -Bei der Ausführung von configure die Option --prefix mit dem Zielverzeichnis - angeben.
- -PostgreSQL ist standardmäßig so eingestellt, dass Verbindungen nur vom - lokalen Rechner über Unix Domain Sockets bzw. TCP/IP möglich sind. - Verbindungen von anderen Rechnern werden erst dann ermöglicht, wenn Sie - in der Datei postgresql.conf die Einstellung listen_addresses - anpassen, in der Datei $PGDATA/pg_hba.conf host-basierte - Authentifizierung einschalten und den Server neu starten.
- -Es gibt drei große Bereiche, in denen Performanzverbesserungen - erzielt werden können:
- -Unter den Optionen für die Server-Konfigurierung gibt es zahlreiche - log_*-Variablen, die die Ausgabe von Abfrage- und Prozessstatistiken - ermöglichen. Diese können für Debugging-Zwecke sowie Performanz-Tests sehr - nützlich sein.
- -Ihr System hat die maximal zulässige Anzahl von Datenbankverbindungen - erreicht (Voreinstellung 100). Sie müssen die maximale Anzahl der - gleichzeitig ausführbaren Backend-Prozesse hochsetzen, indem Sie in - postgresql.conf den Wert max_connections ändern und - den Server neustarten.
- - -Allgemeine Informationen zur Aktualisierung von PostgreSQL gibt es auf der - Seite http://www.postgresql.org/support/versioning. - Detaillierte technische Informationen gibt es auf der Seite - http://www.postgresql.org/docs/current/static/install-upgrading.html -
- - -PostgreSQL läuft auf fast jeder Hardware-Kombination. Im PC-Bereich - gibt es allerdings sehr große Abweichungen in der Qualität. Für einen - Arbeitsplatz- oder Entwicklungsrechner mag dies nicht so bedeutend sein, - im Server-Betrieb jedoch lohnt sich auf jeden Fall die Investition - in teurere Bestandteile (Stichwörter ECC-Speicher, SCSI, Hauptplatinen - und Netzteile von namhaften Herstellern). Nutzen Sie unsere Mailing-Listen, - um Hardware-Optionen zu diskutieren. -
- -Wenn Sie bei der Ausführung der Abfrage die Anzahl der anzufordenden - Reihen bereits kennen, nutzen Sie LIMIT. Wenn die ORDER BY- - Anweisung mit einem Index verwendet wird, ist es möglich, dass die - gesamte Abfrage nicht ausgeführt werden muss. Wenn Sie die Anzahl der - der anzufordenden Reihen nicht kennen, verwenden Sie einen Cursor - und FETCH. - -
Um eine beliebige Zeile auszuwählen, nutzen Sie ORDER BY random():
-- SELECT spalte - FROM tabelle - ORDER BY random() - LIMIT 1 -- -
In psql zeigt der Befehl \dt eine Liste der Datenbanktabellen. Weitere psql-Befehle - lassen sich mit \? anzeigen. Sie können sich die Datei pgsql/src/bin/psql/describe.c - mit dem Quellcode für psql ansehen. Sie enthält die SQL-Abfragen, die die - Backslash-Kommandos (\) ausführen. Sie können psql auch mit der -E - Option starten. Danach gibt psql die Abfragen aus, die es bei der Ausführung der Befehle - benutzt. Außerdem biete PostgreSQL ein SQL-kompatibles INFORMATION SCHEMA, - das Metainformation über die Datenbank zur Verfügung stellt.
- -Mit psql -l können Sie alle Datenbanken anzeigen lassen.
- -Die Datei pgsql/src/tutorial/syscat.source enthält außerdem viele SELECT- - Abfragen, mit deren Hilfe man Information über die Systemtabellen erhalten kann.
- -Ab Version 8.0 kann der Datentyp einer Spalte mit ALTER TABLE ALTER COLUMN TYPE - geändert werden, sofern der neue Datentyp die Werte des alten Datentype aufnehmen - kann.
- -Bei früheren Versionen gehen Sie wie folgt vor:
- -- BEGIN; - ALTER TABLE tabelle ADD COLUMN neue_spalte neuer_datentyp; - UPDATE tabelle SET neue_spalte = CAST(alte_spalte AS neuer_datentyp); - ALTER TABLE tabelle DROP COLUMN alte_spalte; - COMMIT; -- -
Um den Speicherplatz freizugeben, der von der gelöschten Spalte verwendet - wurde, führen Sie VACUUM FULL aus.
- -Es bestehen folgende Obergrenzen:
-- Maximale Größe eine Datenbank? unbeschränkt (es existieren - Datenbanken mit 32 TB) - Maximale Größe einer Tabelle? 32 TB - Maximale Größe einer Zeile? 400 GB - Maximale Größe einer Spalte? 1 GB - Maximale Anzahl von Zeilen in einer Tabelle? - unbeschränkt - Maximale Anzahl von Spalten in einer Tabelle? - 250-1600 je nach Spaltentyp - Maximale Anzahl von Indexen für eine Tabelle? - unbeschränkt - --
Selbstverständlich sind dies theoretische Werte, die oft durch die - verfügbaren Platten- und Speicherressourcen beschränkt werden. - Extreme Größen können zu Leistungseinbußen führen.
- -Die maximale Tabellengröße von 32 TB benötigt keine Large-File-Unterstützung - im Betriebssystem. Große Tabellen werden in Dateien mit einer Größe von - je 1 GB aufgeteilt, wodurch etwaige dateisystem-bedingte Beschränkungen nicht - relevant sind.
- -Die maximale Tabellengröße und die maximale Anzahl von Spalten können - vervierfacht werden, indem man die Default-Blockgröße auf 32 KB heraufsetzt. - Die Tabellengröße kann auch durch Tabellenpartitionierung vergrößert - werden.
- -Eine Einschränkung ist, dass Indexe nur auf Spalten erstellt werden - können, die bis etwa 2.000 Zeichen groß sind. Um auf größere Spalten - eine UNIQUE-Constraint setzen zu können, nutzen - Sie einen funktionalen Index mit dem MD5-Hash-Wert der Spalte. - Um innerhalb einer großen, mit Text belegten Spalte suchen zu können, - verwenden Sie einen Volltext-Index.
- -Eine PostgreSQL-Datenbank kann beim Abspeichern einer einfachen Textdatei - bis zu fünfmal mehr Platz gegenüber der eigentlichen Größe der Datei - beanspruchen.
- -Betrachten wir eine Datei mit 100.000 Zeilen mit einem Integer und einer - Textbeschreibung pro Zeile. Gehen wir davon aus, dass die durchschnittliche - Länge der Textbeschreibung 20 Byte beträgt. Die einfache Datei würde 2,8 MB - groß sein. Die Größe der PostgreSQL-Datenbankdatei, die diese Daten enthält, - liegt ungefähr bei 5,2 MB:
-- 24 Bytes: jeder Zeilenkopf (ungefähr) - +24 Bytes: ein Integer-Feld und ein Textfeld - + 4 Bytes: Zeiger auf der Datenseite auf den Tupel - ----------------------------------------------- - 52 Bytes pro Zeile --
Die Größe einer Datenseite in PostgreSQL beträgt 8192 Bytes (8 KB), also:
- -- 8192 Bytes pro Seite - --------------------- = 146 Zeilen pro Seite (abgerundet) - 52 Bytes pro Zeile - - 100.000 Datenzeilen - ------------------------ = 685 Datenbankseiten (aufgerundet) - 158 Zeilen pro Seite - - 633 Datenbankseiten * 8192 Bytes pro Seite = 5,185,536 bytes (5,2 MB) --
Indexe beanspruchen nicht so viel Platz. Da sie jedoch die - Daten beinhalten, die sie indizieren, können auch sie sehr groß werden.
- -NULL-Werte werden als Bitmaps gespeichert, wodurch sie sehr wenig - Platz in Anspruch nehmen.
- -Indexe werden nicht automatisch bei jeder Abfrage verwendet. Indexe werden - nur dann verwendet, wenn die abzufragende Tabelle eine bestimmte Größe - übersteigt, und die Abfrage nur eine kleine Prozentzahl der Tabellenzeilen - abfragt. Der Grund hierfür ist der, dass die durch einen Index verursachten - Festplattenzugriffe manchmal länger dauern würden als ein einfaches Auslesen - aller Tabellenzeilen (sequentieller Scan).
- -Um festzustellen, ob ein Index verwendet werden soll, braucht PostgreSQL - Statistiken über die Tabelle. Diese Statistiken werden durch die Anweisungen - VACUUM ANALYZE bzw. ANALYZE berechnet. Anhand der Statistiken kennt der - Abfragenoptimierer die Anzahl der Tabellenzeilen und kann besser - entscheiden, ob Indexe verwendet werden sollen. Statistiken sind auch - bei der Ermittlung der optimalen JOIN-Reihenfolgen und - -Methoden wertvoll. Daher sollten diese regelmässig durchgeführt werden, da - sich der Inhalt einer Tabelle ja auch verändert.
- -Indexe werden normalerweise nicht in ORDER BY-Abfrage oder in JOINs - verwendet. Ein sequentieller Scan mit anschließendem explizitem - Sortiervorgang ist normalerweise schneller als ein Index-Scan einer - großen Tabelle. Jedoch wird bei einer Abfrage, in der LIMIT zusammen mit - ORDER BY verwendet wird, oftmals ein Index verwendet, da nur ein - kleiner Abschnitt der Tabelle zurückgeliefert wird.
- -Sollte es danach aussehen, also ob der Optimierer irrtümlich einen sequentiellen - Scan ausführt, führen Sie SET enable_seqscan TO 'off' aus und prüfen - Sie, ob die Indexabfrage dadurch scheller geworden ist.
- -Bei der Nutzung von Wildcard-Operatoren wie LIKE oder ~, können - Indexe nur unter bestimmten Umständen verwendet werden:
-In Versionen vor 8.0 werden Indexe oft nicht benutzt, wenn die - jeweiligen Datentypen nicht genau übereinstimmen. Dies gilt besonders für - Indexe auf Spalten mit den Datentypen INT2, INT8 und NUMERIC
- - -Vgl. die EXPLAIN Man-Page.
- -Der Operator ~ wendet einen regulären Ausdruck an und ~* wendet ihn an, ohne die Groß- und Kleinschreibung zu beachten. - Ebenso beachtet LIKE die Groß- und Kleinschreibung, und ILIKE nicht.
- -Gleichheitsvergleiche, die Groß- und Kleinschreibung ignorieren, werden - in der Regel so ausgedruckt:
- -- SELECT * - FROM tabelle - WHERE LOWER(spalte) = 'abc' --
Hier wird kein normaler Index benutzt. Legt man hingegen einen funktionalen - Index an, so wird er auf jeden Fall verwendet:
-- CREATE INDEX tabelle_index ON tabelle (LOWER(spalte)) --
Falls der obige Index als einen UNIQUE-Index angelegt - wird, können keine Werte in die Spalte eingefügt werden, die sich nur - durch ihre Groß- und Kleinschreibung unterscheiden. Um Fehler zu - vermeiden muß ein CHECK-Constraint oder ein Trigger - eingesetzt werden.
- -Testen Sie die Spalte mit IS NULL bzw. IS NOT NULL.
-- SELECT * - FROM tabelle - WHERE spalte IS NULL --
Um die Spalte danach zu sortieren, ob sie mit NULL belegt ist oder nicht, - verwenden Sie die Bedingungen IS NULL bzw. IS NOT NULL - in der ORDER BY-Klausel. Da Bedingungen, die wahr sind, höher - als das Gegenteil sortiert werden, bewirkt die folgende Abfrage, dass die - NULL-Spalten zuerst gelistet werden:
-- SELECT * - FROM tabelle - ORDER BY (spalte IS NOT NULL) - -- -
-Typ interner Name Bemerkungen -------------------------------------------------- -VARCHAR(n) varchar die Größe legt die Maximallänge fest; kein - Auffüllen mit Leerzeichen -CHAR(n) bpchar mit Leerzeichen gefüllt bis zur angegebenen Länge -TEXT text keine obere Schranke für die Länge -BYTEA bytea Bytearray mit variabler Länge (auch für - '\0'-Bytes geeignet) -"char" char 1 Zeichen --
Der interne Name kommt vor allem in den Systemkatalogen und in manchen - Fehlermeldungen vor.
- -Die ersten vier Typen sind "varlena"-Typen (d.h. die ersten vier - Bytes geben die Länge an, gefolgt von den Daten). Daher ist der tatsächlich - belegte Platz immer etwas mehr als die deklarierte Feldgröße. Allerdings - wird unter Umständen auf diese Datentypen Datenkompression durch das TOAST- - Verfahren angewendet, womit der tatsächlich belegte Platz auch geringer - als erwartet ausfallen kann.
- -Für die Speicherung von Zeichenketten variabler Länge empfiehlt sich VARCHAR(n). - Die maximale Länge eines VARCHAR(n)-Felds wird bei der Tabellendefinition - festgelegt. TEXT setzt keine Längengrenze, allerdings gibt es - eine systembedingte Obergrenze von 1 GB.
- -CHAR(n) ist geeignet für die Speicherung von Zeichenketten, die alle - die gleiche Länge haben. Bitte beachten Sie, dass CHAR(n) automatisch Zeichenketten - bis zur definierten Feldlänge mit Leerzeichen ausfüllt, während bei VARCHAR(n) nur - die tatsächlich eingegebene Zeichenkette gespeichert wird.
- -BYTEA ist für binäre Daten, besonders für Werte, die NULL-Bytes haben.
- -Alle der hier erwähnten Typen weisen ähnliche Performanzeigenschaften auf.
- -PostgreSQL bietet einen SERIAL-Datentyp. Dieser erzeugt automatisch - eine Sequenz auf die angegebene Spalte. Zum Beispiel:
-- CREATE TABLE person ( - id SERIAL, - name TEXT - )- -
wird automatisch in:
-
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
-umgewandelt.
- -Die create_sequence Man-Page liefert weitere Informationen über Sequenzen.
- -Eine Möglichkeit wäre, mit der nextval()-Funktion den nächsten SERIAL-Wert - von dem Sequenzobjekt vor der Auszuführung einer INSERT-Anweisung anzufordern und ihn - dann explizit in die INSERT-Anweisung einzubinden. Anhand der Beispieltabelle in - 4.11.1 könnte dieser Vorgang in einer Pseudosprache so aussehen:
- -
- new_id = output of execute("SELECT nextval('person_id_seq')");
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
-
- Danach stünde der neue Wert in der Variablen new_id für die Verwendung in - weiteren Abfragen zur Verfügung, zum Beispiel als Fremdschlüssel zur - Tabelle 'person'). Bitte beachten Sie, dass der Name des automatisch - erstellten SEQUENCE-Objektes folgenden Name hat: - «table»_«serialcolumn»_seq - wobei 'table' und 'serialcolumn' die Namen der jeweils betreffenden - Tabelle / Spalte darstellen.
- -Als weitere Möglichkeit können Sie nach einer INSERT-Anweisung den - automatisch eingefügten SERIAL-Wert mit der currval()-Funktion zurückgeben - lassen:
-
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
- new_id = output of execute("SELECT currval('person_id_seq')");
-
-
- Nein. currval() liefert einen Wert zurück, der von Ihrer - Datenbank-Session bestimmt wird, und der anderen Sessionen nicht zur Verfügung - steht.
- -Um die gleichzeitige Abarbeitung von Transaktionen zu verbessern, werden - Sequenzen gerade nicht für andere Transaktionen gesperrt, sondern die - Sequenznummern werden den laufenden Transaktionen sofort zugeteilt. Lücken in - der Sequenznummerierung werden durch abgebrochene Transaktionen verursacht.
- -Jede Zeile, die in PostgreSQL erzeugt wird, bekommt eine eindeutige OID, - sofern die Tabelle nicht mit der Option WITHOUT OIDS angelegt wurde. - OIDs sind automatisch zugewiesene 4-Byte-Integer, die innerhalb - der gesamten Datenbank einmalig sind. Allerdings laufen sie bei einem Wert von - ungefähr 4 Milliarden über. PostgreSQL verwendet OIDs, um seine - interne Systemtabellen zu verbinden.
- -Um einmalige Idenfikatoren in Datentabellen zu erstellen, wird allerdings - empfohlen, statt OIDs Werte zu verwenden, die vonSERIAL- - Sequenzen erzeugt werden. SERIAL-Sequenzen sind innerhalb einer - Tabelle einmalig und daher weniger anfällig für Überläufe. Außerdem können - 8-Byte-Sequenzwerte mit SERIAL8 erzeugt werden.
- -CTIDs werden benutzt, um bestimmte physikalische Zeilen - durch Block und Offset Werte zu identifizieren. CTIDs - verändern sich, sobald Zeilen verändert oder zurückgeladen werden. Sie - werden in Indexeinträgen benutzt um auf die physikalischen Zeilen zu - zeigen.
- -Wahrscheinlich gibt es keinen virtuellen Speicher mehr in Ihrem System - oder Ihr Kernel hat niedrige Höchstgrenzen für bestimmte Ressourcen. - Probieren Sie vor dem Start von postmaster folgendes:
-- ulimit -d 262144 - limit datasize 256m - --
Je nach benutzter Shell wird nur einer dieser Befehle erfolgreich - ausgeführt werden. Auf jedem Fall wird die Grenze des Datensegments für - Prozesse erhöht werden und eventuell die erfolgreiche Ausführung der - Abfrage ermöglichen. Falls Sie ein Problem mit dem SQL-CLient haben, - weil das Backend zu viele Daten zurückliefert, versuchen Sie dies vor dem - Start des SQL-Clients.
- -Geben Sie in psql SELECT VERSION(); ein.
- -Dazu verwenden Sie CURRENT_TIMESTAMP:
-- CREATE TABLE test (x INT, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- -
PostgreSQL unterstützt OUTER JOINs nach dem SQL- - Standardsyntax. Hier zwei Beispiele:
-- SELECT * - FROM tabelle_1 t1 - LEFT OUTER JOIN tabelle_2 t2 ON (t1.spalte = t2.spalte) --
bzw.:
-- SELECT * - FROM tabelle_1 t1 - LEFT OUTER JOIN tabelle_2 t2 USING (spalte) -- -
- Diese identischen Abfragen verknüpfen tabelle_1 mit tabelle_2 über die - Spalte 'spalte' und geben außerdem alle unverknüpften Zeilen in tabelle_1 - (diejenigen, die keine Entsprechung in tabelle_2 haben) zurück. - Ein RIGHT JOIN würde hingegen alle unverknüpften Zeilen in tabelle_2 hinzufügen und - ein FULL JOIN würde alle verknüpften Zeilen sowie jeweils alle - unverknüpften Zeilen aus den beiden Tabellen zurückliefern. Die Angabe von - OUTER ist nicht zwingend und kann in LEFT, RIGHT und FULL-Verknüpfungen - weggelassen werden. Normale Verknüpfungen sind INNER JOINs.
- -Es gibt keinen Weg, innerhalb einer Abfrage auf mehr als eine Datenbank - zuzugreifen. Da PostgreSQL datenbank-spezifische Systemkataloge lädt, ist - eine datenbankübergreifende Abfrage nicht möglich.
- -contrib/dblink ist eine Erweiterung, die datenbankübergreifende Abfragen über - Funktionsaufrufe ermöglicht.
- -Funktionen können mehrere Zeilen und Spalten zurückgeben, vgl.: - http://www.postgresql.org/docs/techdocs.17.
- -In PostgreSQL-Versionen vor 8.3 verarbeitet PL/PgSQL Funktionen in einer - Cache. Dies hat eine unangenehme Nebenwirkung, nämlich dass wenn eine - PL/PgSQL-Funktion auf eine temporäre Tabelle zugreift, und diese Tabelle - anschließend gelöscht bzw. neu erstellt wird, die Funktion fehlschlagen - wird, da die gecachten Funktionsinhalte noch auf die alte temporäre Tabelle - zeigen. Die Lösung für diese Probleme besteht darin, in der PL/PgSQL- - Funktion mittels EXECUTE auf temporäre Tabellen zuzugreifen. - Dies bewirkt, dass bei jedem Funktionsruf die betreffende Abfrage neu - geparst wird.
- -Dieses Problem taucht in PostgreSQL 8.3 und späteren Versionen nicht - mehr auf.
- -Der Begriff "replikation" umfasst mehrere verschiedene Technologien, - jede mit eigenen Vor- und Nachteilen.
- -Mit "Master/slave"-Replikation werden Änderungen in einer Hauptdatenbank - durchgeführt und an "Sklaven" verteilt, die im Nur-Lese-Modus arbeiten. - Die populärste Lösung für PostgreSQL ist Slony-I.
- -"Multi-master replication" ermöglicht sowohl lesende als auch schreibende - Zugriffe über mehrere Datenbank-Server hinweg. Allerdings hat diese Art von - Replikation eine negative Auswirkung auf die Performanz durch die - Notwendigkeit, Änderungen zwischen Servern zu synchronisieren. Pgcluster - ist die populärste freie Lösung für PostgreSQL.
- -Es gibt auch einige kommerzielle und hardware-basierte Replikationslösungen - für verschiedene Arten der Replikation.
- -Die häufigste Ursache ist die Verwendung von Gänsefüßchen - bei der Anlegung von Tabellen, z.B.:
-
- CREATE TABLE "Tabelle"
- ("SPALTE1" INT)
-
- Dadurch werden Tabellen- und Spaltennamen (sog. Identifikatoren) - in genau der Schreibweise gespeichert (vgl. - Dokumentation), was dazu führt, dass man sie danach immer - in Gänsefüßchen angeben muss. Im obigen Beispiel muss man also immer - etwa SELECT * FROM "Tabelle" verwenden. Um - dieses Problem zu vermeiden, müssen Sie immer eines der folgenden - Punkte beachten:
- -Die englische Vorlage dieser FAQ wird ständig überarbeitet. Daher liegt - die Übersetzung nicht immer auf dem aktuellsten Stand.
- -Die aktuellste Version der deutschen Übersetzung befindet sich immer unter - http://sql-info.de/de/postgresql/FAQ_german.html. - Diese "Arbeitsversion" enthält eventuell Änderungen, die noch nicht auf der - PostgreSQL-Website eingebunden worden sind.
- -Über Verbesserungshinweise und Korrekturvorschläge sowie Verständnisfragen - zum Inhalt der FAQ freue ich mich. Ich nehme auch allgemeine Fragen zu PostgreSQL gerne - entgegen, verweise jedoch auf die Mailing-Listen als schnelle und zuverlässige - Anlaufstellen.
- - diff --git a/doc/src/FAQ/FAQ_hungarian.html b/doc/src/FAQ/FAQ_hungarian.html deleted file mode 100644 index af03d0cbbcb..00000000000 --- a/doc/src/FAQ/FAQ_hungarian.html +++ /dev/null @@ -1,1668 +0,0 @@ - - - - -Utolsó módosítás dátuma: 2005 május 9.-
Fordítás aktualizálása: 2005 június-
-
-A GyIK karbantartója: Bruce Momjian (pgman@candle.pha.pa.us)
Fordító: Hornyák László-
(laszlo.hornyak.nospam@gmail.com)
-
-A legfrissebb verzió itt érhetõ el (angol):
http://www.PostgreSQL.org/docs/faq-english.html.-
-
-Legfrissebb magyar nyelvû verzió:
http://hackers.forgeahead.hu/space/PostgreSQL/GYIK-
-
-Platform specifikus kérdések:
http://www.PostgreSQL.org/users-lounge/docs/faq.html.-
Így ejstd ki: Post-Gres-Q-L.
-(Vagy talán inkább töltsd le a kis mp3-at a -PostgreSQL homepage-rõl)
-A PostgreSQL a POSTGRES adatbázis management rendszer egy -kiegészítése, ami egy következõ -generációs DBMS kutatási prototípus. -Megtartja a POSTGRES adatmodellét és gazdag -adattípus választékát, de a PostQuel -lekérdezõ nyelvet az SQL egy kiterjesztett -verziójával helyettesíti. A PostgreSQL szabad -és a teljes forráskód -hozzáférhetõ.
-A PostgreSQL fejlesztését egy csapat végzi, -amelynek minden tagja megtalálható a PostgreSQL -fejlesztõi levelezési listán. A jelenlegi -koordinátor -Marc G. Fournier (scrappyp@PostgreSQL.org). Ez a csapat felelõs -minden fejlesztésért. <>A PostgreSQL 1.01 -alkotói -Andrew Yu és Jolly Chen voltak. Sokan járultak -hozzá portolással, teszteléssel, -hibakereséssel és fejlesztéssel. Az eredeti -Postgres kód, amibõl a PostgreSQL származik -Michael Stonebraker professzor irányítása alatt -fejlesztettek az egyetem programozói, tanulói és -végzett tanulói. <>
-A szoftver eredeti neve Postgres volt. Amikor SQL -funkcionalítással egészítették ki -1995-ben, a nevét Postgres95-re változtatták. 1996 -végén kapta mai nevét.
-Az eredeti angol copyright szöveg:-
---------------------
PostgreSQL is subject to the following COPYRIGHT:-
-
PostgreSQL Data Base Management System
-
Portions copyright (c) 1996-2002, PostgreSQL Global Development Group
Portions Copyright (c) 1994-6 Regents of the University of California-
-
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written-
agreement is hereby granted, provided that the above copyright notice-
and this paragraph and the following two paragraphs appear in all-
copies.-
-
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,-
INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND-
ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN-
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.-
-
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF-
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE-
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF-
CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,-
UPDATES, ENHANCEMENTS, OR MODIFICATIONS.-
---------------------
-
Kedveljük ezt a licensz formát és nem áll -szándékunkban megváltoztatni.
- 1.3 -Milyen UNIX operációs -rendszereken fut PostgreSQL?Általában minden UNIX-kompatibilis -operációs rendszer képes arra hogy futtassa a -PostgreSQL-t. Azokat a platformokat, amiken tesztelték a -kiadást -megtalálhatod a installációs -utasítások között.
- 1.4 -Milyen nem UNIX operációs -rendszerek elérhetõek?Kliens
-
A libpq C függvénykönyvtárat, a psql-t -és más felületeket le lehet úgy -fordítani, hogy fussanak MS Windows operációs -rendszereken. Ebben az esetben a kliens MS Windows-on fut és -TCP/IP segítségével kommunikál a Unixon -futó szerverrel. A "win32.mak" állomány a -kiadás része, ennek segítségével -lehet Win32 platformokra lefordítani a libpq-t és a -psql-t. A PostgreSQL ODBC kliensekkel is képes -kommunikálni.
--Szerver
-<>Az adatbázis szerver Cygwin -segítségével -fut Windows NT és Win2k rendszereken. További -információ -található a pgsql/doc/FAQ_MSWIN állományban -és a MS Windows FAQ-ban a következõ helyen: http://www.PostgreSQL.org/docs/faq-mswin.html. -Natív MS Windows NT/2000/XP portok jelenleg fejlesztés -alatt állnak.Az elsõdleges anonim ftp oldal: ftp://ftp.PostgreSQL.org/pub.
-A tükör oldalak listája megtalálható -a -fõ weboldalunkon.
- 1.6 Hogyan -kapok -terméktámogatást?Az elsõdleges lista a pgsql-general@postgresql.org. -Ez -használható a PostgreSQL-lel kapcsolatos -párbeszédekre. Ha fel -szeretnél íratkozni, küldj egy levelet a -következõ tartalommal (nem -tárggyal) a -pgsql-general-request@postgresql.org címre:
--subscribe-
-end-
-subscribe-
-end --
A fejlesztői levelezési lista: -pgsql-hackers-request@PostgreSQL.org a következõ -tartalommal:
--subscribe-
-end-
Van egy IRC csatorna is #PostgreSQL -néven ahol felteheted -kérédseid. A következõ unix paranccsal -csatlakozhatsz: -
-irc -c '#PostgreSQL' "$USER" irc.phoenix.net.
-
-A kereskedelmi terméktámogatást
-nyújtó cégek listája elérhetö
-itt:
-http://www.PostgreSQL.org/users-lounge/commercial-support.html
-
Magyar nyelvű levelezési lista nincs, de ha tudok segiteni a -fenit e-mail cimemen elérhető vagyok.
- 1.7 Melyik -a legfrissebb kiadás?A legfrissebb PostgreSQL kiadás a 8.0.
-A tervek szerint minden évben lesz egy nagyobb
-fejlesztéseket tartalmazó kiadás, míg a
-kisebb fejlesztéseket néhány havonta adjuk ki.
-
Számos kézikönyv, man oldalak és kis teszt -példák találhatóak a kiadásban a -doc/ könyvtár alatt. Az interneten is olvashatod a -dokumentációt a következõ címen:
-http://www.PostgreSQL.org/users-lounge/docs/.
-Két PostgreSQL könyv érhetõ el az -interneten -a http://www.PostgreSQL.org/docs/awbook.html -és a http://www.commandprompt.com/ppbook/ -címeken. A megvásárolható könyvek -listája itt -található: http://www.ca.PostgreSQL.org/books/. -A PostgreSQL-lel kapcsolatos technikai jellegû cikkek -gyûjteménye: http://techdocs.PostgreSQL.org/.
-A psql parancs rendelkezik néhány \d -utasítással, amellyekkel listázhatóak az -operátorok, a funkciók, stb.
-A website is tartalmaz további dokumentációkat.
- 1.9 Hogyan -találok információt -hibákról vagy hiányzó -funkcionalításról?A PostgreSQLaz SQL-92 szabvány egy -kiegészítése. Nézd meg a TODO -listákat ha érdekelnek az ismert hibák.
- 1.10 Hogy -tanuljam meg az SQL nyelvet?A PostgreSQL könyv a -http://www.PostgreSQL.org/docs/awbook.html -címen tartalmaz SQL -alapokat. Elérhetõ egy -másik SQL könyv is a http://www.commandprompt.com/ppbook -címen. Egy szép -oktató anyag található a -http://www.intermedia.net/support/sql/sqltut.shtm, -a -http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM -és a http://sqlcourse.com -oldalakon. -
-Egy másik lehetõség a "Tanítsd magad 21 -nap -alatt SQL-re, második kiadás" a -http://members.tripod.com/er4ebus/sql/index.htm.
--Sok felhasználónak tetszett a gyakorlati SQL könyv -("The Practical SQL Handbook").
-Igen, könnyedén kezeli a 2000 utáni és -idõszámításunk elött 2000 elötti -dátumokat is.
-Számos nézõpontból lehet -vizsgálni -a -szoftvert: képességek, teljesítmény -megbízhatóság, támogatottság -és ár.
-Képességek: -A PostgreSQL rendelkezik a nagy, kereskedelmi DBMS-ek -képességeivel: tranzakciók, -al-lekérdezések, triggerek, -nézetek, külsõ kulcsok, integrítás -és kifinoult zármechanizmusok. -Van néhány képessége, ami a kereskedelmi -adatbázisokból hiányzik, mint -például a felhasználó által -definiált típusok, -öröklõdés, szabályok és -verzió kontroll a zárolási viták -redukálásáért. -Teljesítmény: -A PostgreSQL teljesítménye hasonlít a -kereskedelmi -és más nyílt adatbázis -szerverekéhez. Lehet bizonyos esetekben -lassabb, másokban gyorsabb. A MySQL nevû tanuló -RDBMS például gyorsabban hajt végre insert/update -mûveleteket, mivel a tranzakciókat -elsumákolja. Persze a MySQL nem rendelkezik a -képességek -részben felsoroltak nagy részével. Mi a -megbízhatóságra -és a képességekre építünk, -bár a teljesítmény is nõ minden -kiadással. Van -egy érdekes oldal a MySQL és a PostgreSQL -összehasonlításával a -http://openacs.org/philosophy/why-not-mysql.html -címen. -
-Megbízhatóság: -Tudjuk hogy ha egy DBMS nem megbízható, akkor -teljesen -haszontalan. Igyekszünk jól tesztelt, stabil kódot -kiadni, amiben -a lehetõ legkevesebb hiba van. Minden kiadás -elött eltellik -legalább 1 hónap béta teszt, és a -kiadási -történet is azt mutatja, hogy stabil kódot adunk ki, -ami készen áll a -produktív felhasználásra. Úgy gondoljuk, -felülmúlunk más -adatbázis szoftvereket ezen a téren. -
- -Támogatás: -A levelezési listáink kapcsolatot teremtenek a -fejlesztõk és felhasználók -csoportjával , akik -segítenek a problémák megoldásában. -Bár nem tudjuk garantálni -hogy ki tudjuk javítani a hibát, más, kereskedelmi -adatbázis cégek sem tudják. A fejlesztõ -csoport közvetlen elérési -lehetõsége, a közösség, a -dokumentáció és a forráskód -gyakran támogatást biztosít, mint más -adatbázisoknál. Van kereskedelmi, alkalmi -támogatás azoknak, akiknek szüksége van -rá (lásd: 1.6). -
- -Ár: A -PostgreSQL szabad bármilyen -felhasználásra, -akár kereskedelmire is. A termékhez hozzáadhatod a -saját -forráskódjaidat korlátozás -nélkül.
- 1.15 -Hogyan tudom üzletileg segiteni a -PostgreSQL-t?A PostgreSQL elsõ osztályú -infrastruktúrával rendelkezik, amit 1996-ban -indítottunk el. Mindent Marc Fourniernek -köszönhetünk, aki létrehozta és -karbantartja a rendszert. -
-A minõségi infrastruktúra nagyon fontos egy -nyilt -forrású szoftver esetében. Megvéd az olyan -fennakadásoktól, -amelyek komoly késéseket okoznak a -fejlesztésekben. Természetesen ez az -infrastruktúra nem olcsó. -Számos havi és állandó kiadásunk -van. Ha a cégednek van pénze, amivel -támogatná erõfeszítéseinket, -kérlek látogass el a http://store.pgsql.com/shopping/ -oldalra.
--Bár a weboldal "PostgreSQL, Inc"-ként -említi, a -hozzájárulások kizárólag a -PostgreSQL fejlesztésre értendóek, és nem -egy meghatározott cégnek. Ha jobban tetszik, -küldhetsz csekket is a kapcsolati címek -bármelyikére.
-1.16 Ki
-irányítja a PostgreSQL-t?
-
Ha -központi bizottságot, ellenörző céget keresel a -PostgreSQL mögött, add fel, nincs ilyesmi. Létezik egy -mag és CVS commiter csoport, de ez inkáb adminisztrativ -mint ellenörző célú. A projectet fejlesztők -és felhasználók közössége -irányítja, amihez bárki csatlakozhat. -Csupán annyit kell tenned hogy felíratkozol a -levelezőlistékra és részt veszel a -beszélgetésekben.
- -Két ODBC meghajtó érhetõ el: PsqlODBC -és a OpenLink ODBC.
-A PsqlODBC a PostgreSQL kiadás része. További -információ található a -ftp://ftp.PostgreSQL.org/pub/odbc/ oldalon.
-Az OpenLink ODBC-t a http://www.openlinksw.com -címrõl -töltheted le. Ez az õ szabványos ODBC kliens -szoftverükkel -mûködik, így minden
-általuk támogatott platformon (Win, Mac, Unix, VMS) -elérhetõ lesz a PostgreSQL szerver.
-Talán olyan vevõknek fogják eladni, akik -kereskedelmi minõségû terméket -szeretnének kapni, de a freeware verzió mindig -elérhetõ lesz. Kérdéseidet a -termékkel kapcsolatban a postgres95@openlink.co.uk -címen teheted fel.
-Olvasd el az ODBC fejezetet is a programozók -kézikönyvében!
-2.2 -Milyen -eszközök állnak -rendelkezésre PostgreSQL Web fejlesztésekhez?
-Egy szép bemutató olvasható az -adatbázissal -támogatott web oldalanról a http://www.webreview.com -weboldalon.
-A web integrációhoz a PHP egy kiválló -szoftver. Letölthetõ a http://www.php.net -címrõl.
-Komplexebb esetekre sokan használják a Perl -felületet és a CGI.pm vagy a mod_perl-t.
-2.3 Van a -PostgreSQL-hez grafikus -felhasználói felület?
-Van egy szép PgAccess nevû grafikus -felületünk, -ami riport generátorként is használható. A -weboldalát megtalálod a -http://www.pgaccess.org/ -címen.
-A http://techdocs.postgresql.org/guides/GUITools
-oldalon találhatsz egy pontos és részltes
-listát.
-
2.4 -Milyen -programozási nyelvekkel lehet -elérni a PostgreSQL szervert?
-A következök:
-A configure script --prefix paraméterének -használatával.
- 3.2 AMikor -elindítom a postmaster-t, egy -"Bad System Call"-t vagy core dump-ot kapok. Miért?Számos probléma lehet, de legelösször -ellenõrizd le, hogy a kerneled System V -kiegészítésekkel rendelkezik-e. A -PostgreSQL használja a kernel osztott memória és -szemafor API-ját.
-3.3 -Amikor -megpróbálom inditani a -postmaster-t, "IpcMemoryCreate" hibákat kapok. Miért?
--Vagy nincs megfelelõen konfigurálva a kerneled osztott -memória támogatása vagy meg kell -nagyobbítanod a maximális osztott -memória méretet.
-A pontos méret szükséglet függ az -architektúrádtól és attól hogy -hány buffert és processzt konfigurálsz a -postmasternek. -Legalább 1 MB területre szükséged van. A -PostgreSQL -Adminisztráció kézikönyvben olvashatsz -részletesebb információkat az osztott -memóriáról és a szemaforokról.
-3.4) Amikor -megpróbálom inditani a -postmaster-t, "IpcSemaphoreCreate"Ha a hibaüzenet ez: " IpcSemaphoreCreate: semget failed (No -space left on device)", akkor a kerneled konfigurációja -nem -tesz lehetõvé elegendõ szemafort. A PostgreSQL -szerver processzenként 1 -szemafort igényel. Egy átmeneti megoldás lehet az -hogy a -postmastert kevesebb maximális processz számmal inditod -el. Használd a --D paramétert. Egy sokkal megfelelõbb megoldás az -ha növeled a -kerneled SEMMNS és SEMMNI paramétereit.
-A hibás szemaforok is adatázis -lerobbanásához is vezethet nagy terhelés -esetén.Ha a hibaüzenet valami más, lehet hogy nincs -szemaforok -támogatás
-forditva a kerneledbe. Olvasd el a PostgreSQL -adminisztrátorok kézikönyvében az osztott -memóriáról és a szemaforokról -szóló fejezetet.
-3.5) -Hogyan tudom kontrollálni a más -gépekrõl érkezõ kapcsolat -kéréseket?
-Alapértelmezésben a PostgreSQL a helyi kapcsolatokat -Unix -socketekkel valósítja meg. Más gépek nem -lesznek -képesek csatlakozni, ha nem engedélyezed azt -i -opcióval a postmasternek, és -nem állítod be host a alapú -azonosítást a pg_hba.conf -állományban. Ezzel válnak lehetõvé a -TCP/IP kapcsolatok.
-3.6) -Hogyan tudom nagyobb -teljesítményre hangolni az adatbázisomat?
-Az indexelés feltétlenül gyorsítja a -lekérdezéseket. Az EXPLAIN parancs lehetõvé -teszi hogy lásd, hogy a -PostgreSQL miként interpretálja a -lekérdezést és melyik indexet használja.
-Ha sok INSERT mûveletet hajtassz végre, csináld -nagy kötegekben a COPY paranccsal. Ez sokkal gyorsabb mint az -egyedi INSERT parancsok. -Másodszor: Azok a mûveletek, amelyek nincsenek -tranzakció blokkon -belül, azok saját tranzakciót indítanak. Sok -mûveletet érdemes -egy tranzakción belül végrehajtani. Ez -csökkenti a tranzakció -kezelés többletidejét. Az indexeket javasolt a nagy -adatváltozások elött -eltávolítani, majd újra létrehozni.
-Számos teljesítmény javító -lehetõség van. Kikapcsolhatod az fsync() mûveletet -a postmaster -o -F opciókval való -indításakor. Így nem fog az amugy lassú -fsync() függvény -meghívódni minden tranzakció végén.
-Használhatod a postmaster -B opcióját is az -osztott memória szegmens méretének -növeléséhez. Ha az -értéket túl magasra állítod, lehet -hogy a postmaster nem indul el, mert túllépted az -operációs rendszer által megengedett -méretet. Minden buffer 8K méretû -és alapértelmezésban 64 buffer van.
-A -S opcióval növelheted a szerver átmeneti -rendezésekre fenntartott memória területét. -Az értéket -kilobyteban add meg. Az alapértelmezett érték -512K.
-Használhatod a CLUSTER utasítást is, hogy a
-táblákat egy indexnek megfelelõen
-csoportosítsd. Olvasd el a CLUSTER
-kézikönyv oldalt további részletekért.
-
Hardver kiválasztásában segíthet: http://candle.pha.pa.us/main/writings/pgsql/hw_performance/index.html
-és http://www.powerpostgresql.com/PerfList/.
-
A postgresql.conf beállitásaival kapcsolatos -tudnivalók: http://www.varlena.com/varlena/GeneralBits/Tidbits/annotated_conf_e.html -és http://www.varlena.com/varlena/GeneralBits/Tidbits/perf.html.
- -3.7) -Milyen hibakeresõ -lehetõségek érhetõek el?
-A PostgreSQL számos lehetöséggel rendelkezik ami -értékes lehet a hibakeresésnél.
-Elösször is, futtathatod a configure scriptet ---enable-cassert opcióval, sok assert() -funkcióhivás ellenörzi -a program futását és megállitja ha valami -vératlan hiba történik.Mind a postmaster és a postgres számos hibakeresö -lehetüséggel rendelkezik. Mindig amikor elinditod a -postmastert, gyözödj meg -róla, hogy a kimenetet log állományba -küldöd. Igy:
-cd /usr/local/pgsql
-./bin/postmaster >server.log 2>&1 &
-Ez egy server.log állományt hoz létre a -felsö -PostgreSQL könyvtárban. Ez az állomány -tartlamaz majd számos hasznos -információt a szerverrel kapcsolatos -problémákról és -hibákról. A postmaster -d opciójával lehet -részletesebb hibakeresö információt kapni. A --d opcióhoz meg kell határozni egy hiba szintet. -Vigyázz, a magas -hibakeresö szint nagy log állományt okozhat.
-Ha a postmaster nem fut, akkor futtathatod a postgres szervert -parancssorból is, és az SQL kifejezést -közvetlenül ennek adhatod át. Ez csak -hibakeresés esetében javasolt. Az új sor a -kifejezés végét jelenti, nem a pontosvesszö. -Ha hibakeresö opciókkal -forditottad a szervert, használhatsz egy debuggert is hogy -lásd hogy mi -történik. Mivel igy a szervert nem a postmaster inditotta, -nem -többfelhasználós környezetként fut, igy -a zárolási és a szerverek -közötti kommunikációs hiba jelenségek -nem jelentkeznek.
-Ha már fut a postmaster, indits egy psql-t, és -nézd meg a szerver processz PID-jét! Egy debuggert -használhatsz a processzhez -csatlakozáshoz. Beállithatsz töréspontokat -és elindithatsz -lekérdezéseket. Ha a postgres inditásban keresel -hibát, a PGOPTIONS környezeti -változót állitsd be "-W n" értékre. -Ez n másodperc várakozást -idéz elö, igy tudsz csatlakozni a processzhez, el tdsz -hejezni töréspontokat, majd -folytathatod a indítást.
-A postgres program -s, -A és -t opciói is nagyon -hasznosak lehetnek hibakeresésnél és -teljesítmény -mérésnél.
-Profiling lehtöséggel is fordithatod a szervert, hogy -lásd melyik funkciók foglalják el a futási -idõt. A -szerver profile állományai a pgsql/data/base/dbname -könzvtárba kerülnek, a kliens -profile állományok az aktuális -könyvtárba. -Linuxon ehhez szükséges a -DLINUX_PROFILE -fordítási direktiva.
- 3.8) -Miért kapok "Sorry, too many clients" -(Túl sok kliens)Növelned kell a postmaster egyidejûleg futtatott szerver -processz szám korlátját.
-Az alapértelmezett korlát 32 processz. Ezt -növelhetjed úgy, hogy újrainditod a postmastert -és -N opcióval -meghatárotod az új értéket, vagy -módositod a postgresql.conf-ot.
-Ne felejtsd el, hogy ha növeled a szerver processzek -maximális számát, akkor bufferek -számát is növelned kell, -legalább a processzek számának -kétszeresére. Nagy processz számokesetében -valószinüleg a Unix konfigurációs -paramétereken is növelni kell. -Ellenörizd a SHMMAX (az osztott memória szegmensek -maximális mérete), -a SEMMNS és a SEMMNI (a szemaforok maximális -száma), az NPROC (a processzek -maximális száma), a MAXUPRC -(felhasználónkénti maximális -processz szám) és a NFILE és NINODE (a megnzitott -állománzok maximális száma) -paramétereket. A PostgreSQL azért korlátozza -külön a processz -számot, hogy a rendszeredet ne terhelhesse meg -túlságosan.
-A PostgreSQL 6.5 verzióban a maximális szerver -processz -szám 64 volt és a módositáshoz bele kellett -irni a -include/storage/sinvaladt.h állományba és -újra kellett forditani a servert.
-3.9) Mi van pgsql_tmp -könyvtárban?Ez a könyvtár a lekérdezés -végrehajtó által létrehezott -átmeneti állományokat tartalmazza. -Például ha egy -rendezést kell végrehajtani egy ORDER BY kifejezés -miatt és a m?velet több -memóriát vesz igénybe, mint amennyit a -S -paraméter megenged, akkor az -átmeneti könyvtárban hoz létre egy -állományt a -fennmaradó adat tárolására.
-Az átmeneti állományok többnyire -törl?dnek, de meg is maradhat ha például -váratlan hibával leáll a -szerver egy rendezés közben. Inditáskor és -leállitáskor ezeket az -állományokat törli a postmaster.
- 3.10) -Miért kell dumpolni és -újratölteni PostgreSQL kiadás -váltásánál?A PostgreSQL csapat csak apróbb -változtatásokat -hajt végre a kisebb kiadások között, igy ha 7.2 -verzióról -állsz át 7.2.1 verzióra, akkor nem -szükséges kidumplonod az adatbázist. A nagy -kiadások esetében (például -verzióról 7.3-ra áttérésnél) -változik a belsiõ adatstruktúrák és -adatállományok formátuma. Ezek a -változások gyakran nagyon összetettek, ezért -inkáb nem tartunk fenn visszafelé -kompatibilitást. A dump az adatot általános -formátumban irja ki, majd az -új formátumban lehet azt visszatöleni. -
-Azokban a kiadásokban, amelyek között az adat -formátum nem változik, a pg_upgrade program -használható dumpolás -és helyreállitás nélkül. -Nézd meg a DECLARE dokumentációját.
- 4.2) -Hogyan tudom select-elni a -lekérdezés elsõ pár sorát?Olvasd el a FETCH dokumentációját, vagy -használd a SELECT LIMIT-et.
-Az egész lekérdezést végre kell
-hajtani,
-még akkor is, ha csak az elsõ pár sort akarod
-megkapni. Gondolj arra, hogy a
-lekérdezésben lehet ORDER BY is. Ha van olyan index, ami
-megfelel az ORDER BY kifejezésednek,
-a PostgreSQL képes lehet az elsö néhány
-rekord
-visszaadására, vagy a teljes lekérdezésnek
-le kell futnia, amig a kért rekordok
-le nem generálódnak.
-
-
4.3) Hogy tudom -kilistázni a -táblákat vagy más dolgokat a PostgreSQL-ben?
-Elolvashatod a psql forrás kódjában a -pgsql/src/bin/psql/describe.c állományban. Ez SQL -parancsokat tartalmaz, amelyek azokat -a kimeneteket állitják elö, amiket a per jellel -kezdödö -parancsok adnak vissza.
- 4.4) -Hogyan tudok eltávolítani egy -oszlopot egy táblából?Ez a funkcionalitás a 7.3 verziótül kezdve -érhetö el az ALTER TABLE DROP COLUMN -nal. A régebbi -vertiókban igy lehet -végrehajtani:
-BEGIN;-
LOCK TABLE old_table;-
SELECT ... -- minden oszlopot, kivétel amit törölni szeretnél-
INTO TABLE new_table-
FROM old_table;-
DROP TABLE old_table;-
ALTER TABLE new_table RENAME TO old_table;-
COMMIT;-
-
A korlátok:
-adatbázis: korlátlan (1 TB az általunk -ismert -lagnagyobb)
-tábla: 16 TB
-rekord/sor 1.6TB
-mezö 1 GB
-a tábla sorainak száma: korlátlan
-a tábla oszlopainak száma: 250-1600 az oszlop -nevektõl függöen
-A tábla indexeinek száma: korlátlan
-Természetesen nem igazán korlátlan, de a -tárterület, memória és egyéb -külsö tényezök korlátozzák. A -teljesitmény romolhat, ha ezek az értékek -szokatlanul nagyok.
-A 16 TB-os legnagyobb tábla méret nem igényel -nagy -állomány támogatást. A nagy -táblák több 1 GB méretü -állományba kerölnek, igy az állomány -rendszer korlátai nem lényegesek.
-A maximális tábla méret és az oszlopok -maximális oszlop szám növelhetö, ha az -alapértelmezett blokkméretet 32k-ra növeled.
- 4.6) -Mekkora adatbázis lemez terület -szükséges egy tipikus szöveg állományA PostgreSQL akár a szöveg állomány -helyigényének ötszörösét is -elfoglalhatja.
-Képzelj el például, egy 100.000 soros -szöveget, aminek minde sora egy számból és -egy szövegbõl -áll. Tegyük el, hogy átlagosan 20 byte hosszú -szövegek. Ez a szövegállomány -körülbelül 2.8 MB helyet foglalna el. A tábla ami -a fenti adatszerkezetet eltárolná, -körülbelül 6.4 MB-os lenne. Ezt a -következöképpen számolhatjuk ki:
-36 byte: sor fejléc
-24 byte: egy int mezö + egy szöveg mezö-
4 byte: mutato-
----------------------------------------
64 byte soronkent.-
Az adat oldal mérete a PostgreSQL-ben 8192 byte, igy 8192 / -64 = 128 rekord adatbázis oldalanként -(lefelé kerekitve).
-100000 rekord / 128 rekord oldalanként = 782 adat oldal-
(felelé kerekitve).
782 adatbázis oldal * 8192 byte olalanként = 6,406,144-
byte (6.4 MB)
Az indexek nem foglalnak túl sokat, de tartalmazzák az -indexelt adatot, igy ezek is lehetnek nagyok.
-A NULL értékek bittérképben vannak -tárolva, igy kevés helyet foglanak.
-4.7) Hogy -tudhatom meg milyen táblák, -indexek, adatbázisok vagy felhasználók
-vannak definiálva?A psql-ben találsz számos '\' karakterrel -kezdödö utasítást az ilyen -információk listázására. A '\?' -segitségével tudot kilistázni ezeketa parancsokat. -Ezen kivül vannak rendszer táblák, -amelyek nevei 'pg_'-vel kezdödnek.
-Próbáld ki a pgsql/src/tutorial/syscat.source -állományt is. Ez sok példát tartalmaz az -rendszertáblákon -végrehajtott SELECT-ekröl.
-4.8) A -lekérdezéseim lassúak, -vagy nem használják az indexeket. Miért?
- -Az indexeket nem használja a szerver minden -lekérdezésnél automatikusan. Csak akkor -használ indexet, ha a tábla mérete egy -megadott alsó határ felett van, és a -lekérdezés csak a sorok egy kis -részét érinti. Ez azért van, mert a -véletlen hozzáférés még -mindig lassabb lehet mint az tábla szekvenciális -olvasása.
-Hogy a PostgreSQL meg tudja határozni hogy kell-e indexet -használni, léteznie kell egy statisztikának a -tábláról. Ez a statisztikai adatok a VAACUM -ANALYZE vagy az egyszerû ANALYZE mûveletek -során jönnek létre. A statisztikai adatok -felhasználásával az optimalizáló meg -tudja határozni, hogy hány sor van a -táblában, és el tudja dönteni, hogy -használjon-e indexet. A statisztiaki -adatgyüjtést idõnként végre kell -hajtani, ahogy a tábla adatai változnak.
-Az indexeket normális esetben nem használja az ORDER -BY -vagy az OUTER JOIN. A szekvenciális olvasás -általában gyorsabb, mint az index keresés egy nagy -táblában. Bár a LIMIT az ORDER BY-val -kombinálva használhat -indexet, mert a tábla csak kis része érintett. -Bár a MIN -és MAX SQL funkciók sem használják az -indexeket, ezeket az -értékeket egy ORDER BY + LIMIT -lekérdezéssel is le lehet kérdezni:
-SELECT col-
FROM tab-
ORDER BY col [ DESC ]-
LIMIT 1;-
Amikor helyettesítõ jel operátorokat -használsz, mint a LIKE kulcsszó vagy a ~, az indexeket -csak bizonyos körülmények -között lehet használni:
-A keresõ string kezdete a keresési minta elején -kell hogy legyen. Például:
-Olvasd el a dokumentáció EXPLAIN-ról -szóló részét.
- -Az R-tree index a térbeli adat indexelésére -alkalmas. Egy hash index nem képes tartomány -keresésekre. A B-tree -index csak egy dimenzión kezeli a tartomány -kereséseket. -Például ha az indexet egy pont (point adattípus) -típusú mez.re -építjük, gyorsabban kezeli az olyan jellegü -lekérdezéseket, mint egy -adott körben
-található pontok.
-Az R-tree tervezési mintát eredetileg -leíró -szöveg: Guttman, A. "R-trees: A Dynamic Index Structure for -Spatial Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on -Mgmt of Data, 45-57.
-Ezt olvashatod Stonebraker "Readings in Database Systems" c. -könyvében.
-A beépített R-tree kezelni tudják a -sokszögeket (polygon adattípus) és a dobozokat -(box). Elméletileg, az R-tree -kiterjeszthetõ további dimenziókra is. -Gyakorlatilag ezen dolgoznod kell egy kicsit, -és még nincs dokumentációnk arról -hogy az -hogyan mûködik.
-4.11) Mi -a Genetic Query Optimizer?
- -A GEQO modul a lekérdezés optimalizáció -sebességét növeli nagy mennyiségû -tábla összekapcsolása -esetén. Lehetõvé teszi a nagy -lekérdezések végrehajtását nem -teljes kereséssel.
-4.12)
-Hogyan tudok regexp keresést és
-case-insensitive regexp keresést használni? Hogyan tudok
-indexet használni
-case-insensitive kereséshez?
-
A ~ operátor hajt végre reguláris -kifejezés -(regexp) értelmezést, a ~* ennek case-insensitive -változata. A LIKE case-insensitive változata az ILIKE.
-A case-insensitive egyenlõség mûveleteket -általában igy hajtjuk végre:
-SELECT *
-FROM tab-
WHERE lower(col) = 'abc';-
Ez nem fog indexet használni, bár létrehozhatsz -egy funkció indexet:
-CREATE INDEX tabindex ON tab (lower(col));- 4.13) -Hogyan tudom észlelni egy -lekérdezésben, ha egy mezõ NULL?
Használd "IS NULL"-t és az "IS NOT NULL"-t.
-4.14) Mi -a különbség a -különbözõ karaktertípusok között?
-Látni fogod a belsõ elnevezésüket, ha -tanulmányozod a rendszertáblákatés -néhány hibaüzenetet.
-Az utóbbi négy a "varlena" típusok, ami a -tárolásuk módjára utal: az elsõ 4 -byte a lemezen a hosszúság, a többi -az adat. A valódi méret tehát nagyobb mint a -deklarált -hosszúság.Ezek azadatok tömöritve -tárolódnak el, igy kevesebb helyet foglalnek el az -elöre számitottnál.
-A CHAR(n) a legjobb megoldás, ha stabil -hosszúságú stringet tárolsz. A VARCHAR(n) -jó arra az esetekre, ha a hosszúság -változik, de van felsõ korlátja. A TEXT -típus korlátlan -hosszúságú (1 GB-ig) szövegek -tárolására alklamas. A BYTEA bináris adatok -tárolására van. A teljesitmény -mutatói hasonlóak ezenek a -típusoknak.
-4.15.1) -Hogyan tudok létrehozni -automatikusan növekvõ értékû -mezõt?
-CREATE TABLE person (-
id SERIAL,-
name TEXT-
);-
ugyanezt jelenti:
-CREATE SEQUENCE person_id_seq;-
CREATE TABLE person (-
id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
-name TEXT-
);-
CREATE UNIQUE INDEX person_id_key ON person ( id );-
A szekvenciákkal kapcsolatban olvasd el a create_sequence man -oldalt. A sor OID-jét is használhatod egyedi -azonositóként, bár ebben az esetben figyelj a -pg_gump használatánál a --o opcióra (COPY WITH OIDS, másolás OID-dal), hogy -meg?rizd az -értékeket.
-4.15.2) -Hogyan kaphatom meg egy SERIAL -beszúrás értékét?
-Egy megoldás erre az, ha a nextval() funkcióval -megszerzed az értéket még mielött -beszúrnád -az adatot a táblába. Erre itt láthatsz egy -példát:
-new_id = execute("SELECT nextval('person_id_seq')");
-execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise
Pascal')");
--Esetleg lekérdezheted a szekvencia állapotát a sor -beszúrása után.
-execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
-new_id = execute("SELECT currval('person_id_seq')");
--Végül pedig, használhatod a visszaadott OID -értéket is, bár ez a lehetõ -legkevésbé portolható. Perl DBI-ben, Edmund Mergl -DBD::Pg moduljában az OID érték -használható a -$sth->execute() után ($sth->{pg_oid_status}).
- 4.15.3) -A currval() és a nextval() nem -teremt holtpont veszélyes helyzetet a felhasználók -között?Nem. A currval() funkció a szerver processzed által -adott -értéket adja vissza, nem pedig a többi szerver -processz által adottat.
-4.15.4) -Miért nem használódnak fel újra a -sequence számok tranzakció abort esetén?Miért vannak problémák a serial oszlopok -számozásával?
-A párhuzamosság fejlesztése -érdekében a sorozat számokat kérésre -adja ki a szerver futó tranzakcióknak, és azokat -nem zárja, amig a tranzakció véget nem ér. -Ez jukakat okoz a -számozásokban a visszaforditott tranzakciók miatt.
- -Az OID a PostgreSQL egyedi sor azonositója. Minden sor, ami -létrejön a szerveren, kap egy OID-t. Minden OID, amit az -initdb alatt jön -létre 16384 alatt van (lásd include/access/transam.h). -Minden, -felhasználó által létrehozott OID -legalább ennyi. -Alapértelmezésben, az OID nem csak a -táblában vagy az adatbázisban egyedi, -hanem a teljes PostgreSQL adatbázis rendszerben.
-A PostgreSQL az OID-okat a belsö tábláiban -használja a sorok táblák között -összekapcsolásához. Ezek az OID-k -használhatóak a rekordok azonositására is -amikor táblákat csatol -össze a szerver (JOIN). Az OID-ot használhatod mezö -típusként is, -és indexelheted is.
-Az OID érték egy központi területröl -származik, amit minden szerver processz használ. Ha az -OID-ot valami másra -szeretnéd cserélni:
-CREATE TABLE new_table(old_oid oid, mycol int);
-SELECT old_oid, mycol INTO new FROM old;-
COPY new TO '/tmp/pgtable';-
DELETE FROM new;-
COPY new WITH OIDS FROM '/tmp/pgtable';-
Az OID 4 byte-os integer értékként -tárolódik, igy 4 milliárdnál -túlcsordul. Még soha senki nem jelezte hogy ez -történt volna, -és ezt a korlátot igyekszünk eltávolitani, -még mielött -bárki észrevenné.
-A TID a fizikai sorok blokk és offszet címmel -való -azonositására szolgál. A TID változik -minden rekord módositás és -törlés alkalmával. Ezeket az indexek -használják hogy a fizikai sort gyorsan -megtalálják.
-4.17) Mi -a PostgreSQL-ben használt -kifejezések jelentése?
-Néhol a forrás kódban és a -dokumnetációban találhatóak -kifejezések, amelyek általánosabb -jelentéssel bírnak. -Itt van néhány:
-http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary/glossary.html
-Lehet hogy elfogyott a virtuális memóriád, vagy -a -kerneled erõforrás korlátai alacsonyak. -Próbáld ki ezt mielött -elinditanád a postmastert:
-ulimit -d 262144-
limit datasize 256m-
A shelltõl függõen ezek közül csak az -egyik fut majd le, de a processzek adatszegmensét sokkal -magasabbra állitja, ami -talán elég lesz a lekérdezés -végrehajtásához. Ez az utasítás a -jelenlegi processzre (a shelled) érvényes, és -minden -általa létrehozott processzre. Ha problémád -van az SQL klienssel, mert a -szerver túl nagy adatot küld vissza, próbáld -meg e -klienssel is ugyanezt.
-4.19) -Hogyan tudhatom meg PostgreSQL, milyen -verziót futtatok?
-A psql programban select version();
- 4.20) -Miért kapok "invalid large obj -descriptor" hibát nagy objektumok -kezelésénél?A nagy objektumok kezelését egy tranzakciós -blokkban helyezd el. (BEGIN és COMMIT között)
-
-Jelenleg a PostgreSQL ezt a szabályt azzal teszi
-kötelezõvé, hogy a tranzakció
-végén a nagy objektumokat
-lezárja, igy a tranzakció után az elsõ
-mûvelet amit az objektumon
-végrahajtanál hibás lesz.
Ha olyan programozási felületet használsz mint az -ODBC vagy a JDBC akkor valószinûleg ki kell kapcsolnod az -auto-commit-ot.
-4.21)
-Hogy hozhatok létre olyan oszlopot,
-aminek alapértelmezett érétke a jelenlegi
-idõ?
-
Használd a CURRENT_TIMESTAMP -ot:
-CREATE TABLE test (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP );- 4.22) -Miért olyan lassúak az -al-lekérdezéseim IN-nel?
Jelenleg az al-lekérdezéseket a külsõ -lekérdezéshez csatoljuk. Ha az allekérdezés -csak kevés sort eredményez -és a külsõ lekérdezés sokat, akkor az -IN is gyors. Az EXISTS kulcsszó -használatával gyorsithatod a lekérdezéseket.
-SELECT *
-FROM tab-
WHERE col IN (SELECT subcol FROM subtab);-
EXISTS használatával:
-SELECT *-
FROM tab-
WHERE EXISTS (SELECT subcol FROM subtab WHERE subcol = col);-Ahhoz hogy ez gyorsan fusson le, a subcol indexelt oszlopnak kell hogy -legyen. Reméljük ezt a korlátot sikerül -hamarosan legyõznünk. -
4.23) -Hogyan tudok outer join-t végrehajtani?
-A PostgreSQL a szabványos SQL szintaktikát -követi. -Itt van két példa:
-SELECT *
-FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col);-
-vagy
-SELECT *-
FROM t1 LEFT OUTER JOIN t2 USING (col);-
Ezek az identikus lekérdezések -összekapcsolják a t1.col és a t2.col mezõket, -és a t1 bármelyik kapcsolatlan -sorát is visszadják. A RIGHT JOIN a t2 kapcsolatlan -sorait adta volna vissza, a FULL JOIN pedig a kapcsolt, és -mindkét tábla kapcsolatlan sorait -adja. Az OUTER kulcsszó opcionális, a LEFT, RIGHT -és FULL JOIN -szintaktikailag helyes. Az átlagos -összekapcsolásokat INNER JOIN-nak -nevezzük.
-Az elõzõ kiadásokban a OUTER JOIN -lekérdezéseket UNION és NOT IN kulcsszavakkal -lehetett szimulálni. Például a tab1 -és a tab2 összekapcsolása:
-SELECT tab1.col1, tab2.col2
-FROM tab1, tab2
-WHERE tab1.col1 = tab2.col1
-UNION ALL
-SELECT tab1.col1, NULL
-FROM tab1
-WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2)
-ORDER BY col1Arra nincs lehetõség, hogy más -adatbázisból kérdezz le adatot.Mivel a PostgreSQL -adatbázis specifikus rendszer -táblákat töltbe, bizonytalan hogy egy -adatbázisok közötti -lekérdezésnek hogyankellene viselkednie.
-A contrib/dblink könyvtárban találsz egy -megoldást erre, ami funkció hivások -segitségével -mûködik. Persze, a kliens hozhat -létreszimultán kapcsolatot több adatbázissal, -és -összefésülheti az eredményeket.
-4.25)
-Hogy tudok több soros vagy oszlopos
-eredményt visszaadni egy funkcióból?
-
A PL/pgSQL tárolt eljárás nyelvvel refcursor -használatával. Részletesen itt:
-http://www.PostgreSQL.org/idocs/index.php?plpgsql-cursors.html
- 4.26) -Miért nem tudom megbizhatóan -létrehozni és törölni az átmeneti -táblákat a PL/pgSQL funkciókban?A PL/pgSQL cacheli a funkciók tartalmát, aminek az a
-szerencsétlen mellékhatása, hogy ha egy PL/pgSQL
-funkció
-használ egy átmeneti táblát, ami
-később törlõdik majd ujra
-létrejön, akkor az újra lefutó funkció
-nem fogja megtalálni a táblát, mert
-a cache változat a régi táblára tartalmaz
-mutatót. A megoldás erre
-az EXECUTE használata az átmeneti
-táblák
-kezelésére PL/pgSQL-ben. Ez a lekérdezés
-újrafordítását
-fogja elõidézni minden alkalommal.
Bár a replikáció egyetlen terület, -több technológia létezik replikációra, -természetesen mindnek meg vannak a maga előnyei és -hátrányai.
-A master/slave replikációs megoldással a master -adatbázison hajthatunk végre modosításokat, -míg a slave adatbázisokon csak -lekérdezéseket. A PostgreSQL legnépszerűbb -master/slave replikációs megoldása a Solny-I.
-Számos más master/slave replikációs -lehetõség létezik.Egy Listát olvashatsz -ezekrõl itt:
-http://gborg.PostgreSQL.org/genpage?replication_research
-A multi-master replikáció lehetővé teszi -több master adatbázis használatát, bár -ez a technológia drasztikusan csökkenti az adatbázis -teljesítményét a sok szinkornizáció -miatt. A PGCluster a legelterjedtebb ilyen megoldás.
-Egy többfelhasználós replikációs -rendszer készül itt:
-http://gborg.PostgreSQL.org/project/pgreplication/projdisplay.php.
-4.28) -Milyen kódolási -lehetõségek vannak?
-Számos probléma lehet. Elöbb probáld ki a -funkciódat egy különálló -alkalmazásban.
-5.2)
-Hogyan lehet új adattípusokat
-és funkciókat hozzáadni a PostgreSQL disztribúcióhoz?
-
Küldd el a kiegészítéseid a pgsql-hackers -levelezési listára és a forráskodjaid -végül a contrib-ban kötnek ki.
- 5.3) -Hogyan lehet olyan C funkciót -írni, ami Tuple-t ad vissza?A 7.3 verziótól kezdve a PostgreSQL támogatja a -táblázatokat viszzaadó funkciókat C, -PL/pgSQL és SQL nyelveken. -Bõvebb dokumentációt a Programozó -kézikönyvben találsz. Egy C példa -funkció található a contrib/tablefunc -könyvtárban.
-5.4)
-Megváltoztattam egy forrás
-állományt. Miért nem változik a
-bináris újrafordítás
-után?
-
A Makefile-ok nem ismerik a include állományok -megfelelõ függõségeit. Végre kell -hajtanod egy make clean-t, majd újra egy -make-t. Ha GCC-t használsz felhasználhatod a configure -script ---enable-depend opcióját, így a compiler maga -fogja ellenõrizni a -függõségeket.
-原文最終更新日: Thu Jan 01 14:01:00 EDT 2009
-現在の維持管理者: Bruce Momjian (bruce@momjian.us)
-Maintainer of Japanese Translation: Jun Kuwamura (juk at postgresql.jp)
この文書の最新版は - http://www.postgresql.org/docs/faqs.FAQ.html -で見ることができます。
-プラットホームに特有の質問については:
- http://www.postgresql.org/docs/faq/
-
-に解答があります。
-(以下、訳者による注釈を [訳注： と ] とで囲んで記します。)
-[訳注：
- 日本語版のFAQは、
- http://www.postgresql.org/docs/faqs.FAQ_japanese.html
- にあります。
- 最新の日本語版については、この文書の最後にある「日本語版について」をごらんください。
-
-]
-
PostgreSQLはPost-Gres-Q-L(ポスト・グレス・キュー・エル) - と発音しますが、会話の中では単純に Postgres と呼ばれることも - あります。（"PostgreSQL"をどう発音するか気になる人のために、 - - 音声ファイルを用意してあります。
- -PostgreSQL はオブジェクト-リレーショナルデータベースシステムで、 - 伝統的な商用データベースシステムに、次世代DBMSシステ - ムに見られるような改良が施された特徴を有します。PostgreSQLは、無料で - 完全なソースコードを手に入れることができます。
- -PostgreSQL の開発は、ほとんどが、世界中にひろがったボランティアの - 開発者によって、インターネットを通したコミュニケーションによって行わ - れています。コミュニティによるプロジェクトであるため、どの企業の制御 - もうけません。開発に参加したければ、 - http://www.postgresql.org/docs/faqs.FAQ_DEV.html - にある開発者のFAQを見てください。 -
- -PostgresはPostgreSQLの広く使われている愛称です。また、バークレー - でのプロジェクトでもともと使われていた名前で、ほかのいずれの愛称に - 比べても遥かに好ましいです。'PostgreSQL' の発音が難しいと思うのであ - れば、そのかわりに 'Postgres' と呼ぶようにしましょう。
- - -PostgreSQLの門番、中央委員会、あるいは、コントロールをする会社を - 探そうとしても、諦めざるをえず ---- 存在しないのです。我々は、中心 - となるコミッティとCVSコミッタを持ちますが、これらのグループはコン - トロールするためというよりも、管理上のものです。ここでは、プロジェ - クトは、だれでも参加ができる開発者とユーザのコミュニティにより方向 - 付けられます。読者がやらなければならないことは、メーリングリストを - サブスクライブして、議論に 参加することです。（Developer's - FAQには、PostgreSQL開発に加わり方についての情報があります。）
- - -PostgreSQL は下記の著作権に従います。
-PostgreSQLは古くからのBSDライセンスの下で配布されています。それ - は基本的には、利用者がそのコードを好き勝手に利用することが許されて - います。制限があるとすれば、このソフトウェアに伴ういかなる問題にお - いても法的に責任を我々に負わせることができないということです。 - また、この著作権表示がこのソフトウェアのすべての複製に表示すること - も必要です。以下に、我々が実際に使っているBSD使用許諾書を示します： -
- -- [訳注： - 正文は英語です。参考として、訳文を併記掲載します。 - ] --
PostgreSQL Data Base Management System
-- Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-1996 Regents of the University of California
-- Permission to use, copy, modify, and distribute this software and its - documentation for any purpose, without fee, and without a written - agreement is hereby granted, provided that the above copyright notice - and this paragraph and the following two paragraphs appear in all - copies.
-- IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY - FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, - INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS - DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF - THE POSSIBILITY OF SUCH DAMAGE.
-- THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, - INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER - IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO - OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR - MODIFICATIONS.
- -- POSTGRESQL データベース管理システム - - 部分的著作権 (c) 1996-2009, PostgreSQL国際開発グループ - 部分的著作権 (c) 1994-1996 カリフォルニア大学本校 - - - 本ソフトウェアおよびその文書一式は上記の著作権表示と、この文章 - およびこれに続く二つの段落が全ての複製に添付されている限りにおい - て、使用、複製、修正および配付の許可を、いかなる目的であっても、 - 無償でかつ同意書無しに行なえることをここに認めます。 - - カリフォルニア大学は、いかなる当事者にたいしても、利益の壊失を - 含む、直接的、間接的、特別、偶然あるいは必然的にかかわらず生じた - 損害について、たとえカリフォルニア大学がこれらの損害について訴追 - を受けていたとしても、一切の責任を負いません。 - - カリフォルニア大学は、商用目的における暗黙の保証と、特定目的で - の適合性に関してはもとより、これらに限らず、いかなる保証も放棄す - ることを明言します。以下に用意されたソフトウェアは「そのまま」を - 基本原理とし、カリフォルニア大学はそれを維持、支援、更新、改良あ - るいは修正する義務を負いません。 - - [訳注： - 著作権に関する正文は上記の英語による表記です。日本語訳はあくまで - 参考程度としてください。 - ] -- -
一般的に、最近のUnix互換プラットホームであればPostgreSQLを稼働さ - せられるはずです。リリースの時点で実際にテストを行なったことの報告が - なされたプラットホームについてはインストール手引書に列挙してあります。 -
- -PostgreSQL は、Win2000 SP4, WinXP, そして、Win2003 など Microsoft - Windows NTベースのオペレーティングシステムで、ネイティブに走ります。 - あらかじめパッケージにされたインストーラが - http://www.postgresql.org/download/windows - からダウンロードできます。 - MSDOSベースのWindowsのバージョン(Win95, Win98, WinMe)では、Cygwinを - 使って PostgreSQL を走らせることができます。
- -- [訳注 - 日本語での情報は、次の Windows版に関するFAQの和訳をごらんくださ - い（やや古いです）。 - http://old.postgresql.jp/wg/jpugdoc/FAQ_windows.ja.html - ] -- -
次のサイトに Novell Netware 6 への移植版もあります。 - -http://developer.novell.com/wiki/index.php/Postgresql - また、OS/2 (eComStation) バージョンは、 - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2Fにあります。
-Webブラウザ経由だと、 - http://www.postgresql.org/ftp/、それから、ftp経由だと、 - - ftp://ftp.postgresql.org/pub/ を使います。
- - -PostgreSQL の最新版はバージョン 8.3.5 です。
-我々は、1年毎にメジャーリリースを、数ヵ月ごとのマイナーリリースを - 行なうことを計画しています。
- -
- [訳注
- バージョン番号の x.y.z の最初の x.y がメジャーリリースの番号に相
- 当し、最後の z がマイナーリリースの番号になります。メジャーリリー
- スの番号が同じであれば、データベース・クラスタに互換性があります。
- ]
-
PostgreSQL コミュニティは多くのユーザのために、電子メール経由の支 - 援を提供しています。電子メールリストをサブスクライブするためのメイン - となるウェブサイトは - - http://www.postgresql.org/community/lists/です。これから、始める - のであれば general または、bugs といったリストがよいで - しょう。
- -メジャーなIRC チャンネルは、Freenode (irc.freenode.net)の
- #postgresql というチャンネルです。UNIX コマンドでは、
- irc -c '#PostgreSQL' "$USER" irc.freenode.net を使って
- 参加できます。同じネットワークに、スペイン語のチャンネル
- (#postgresql-es)、フランス語のチャンネル
- (#postgresqlfr)、ブラジル語チャンネル (#postgresql-br)
- もあります。また、EFNetにもPostgreSQLチャンネルがあります。
- [訳注:
- 1999年7月23日、日本ポストグレスユーザー会、略称JPUGが設立されました。
- JPUG は非営利組織で、PostgreSQLを利用する人達の相互協力の場となっています。
- (2006年 特定非営利活動(NPO)法人日本PostgreSQLユーザ会になりました。
- Web会員と正会員の会費は無料ですが、協賛会員の会費と会員の貢献で
- 会は運営されています。)
- 詳しくは、JPUG のWeb サイト:
- http://www.postgresql.jp/
- をごらんください。
-
- 日本語のIRCチャンネル '#PostgreSQL:*.jp' も存在します。
- ]
-
商用サポート会社のリストは - http://www.postgresql.org/support/professional_supportにあります。
- - -- http://www.postgresql.org/support/submitbug - のPostgreSQL バグフォームを訪れてください。 バグレポートを提出する仕方 - についての手引と指針があります。
- -それと同時に ftp サイト ftp://ftp.postgresql.org/pub/ - で、最新バージョンの PostgreSQL を探してみてください。
- - -PostgreSQLは拡張されたSQL:2003のサブセットをサポート - します。我々のページの TODO リストに、 - 既知のバグや欠落機能や将来計画についての記述があります。
- - -特徴の要求は普通次のいずれかの解答の中にあります：
-我々は、PostgreSQL に関して、電子メールで直接対応して - TODO - リストを最新に更新してゆくほうがより効果的であることを知っています - ので、バグ追跡システムは使いません。 - 現実に、このソフトウェアの中でバグはそれほど長くはい続けませんし、 - 多くのユーザに影響するバグは早急に修正されます。PostgreSQLのリリース - で、すべての変更点、改良点、そして、修正点を知りたければ、 - CVS - のログメッセージを見てください。リリースノートにさえ、このソフトウェア - に加えられたすべての変更点は網羅されていません。
- - -配付の中に、いくつかのマニュアルとオンライン・マニュアル(マニュ - アル・ページ)およびいくつかの小さなテスト例題が含まれます。 - /docディレクトリをごらんください。また、マニュアルは、 -http://www.postgresql.org/docs/でオンラインでも閲覧できます。 -
- - -
- [訳注:
- JPUG 文書・書籍関連分科会で翻訳されたマニュアルもあります。
-
- http://www.postgresql.jp/document/pg830doc/
- インプレスから、
-
- PostgreSQLオフィシャルマニュアルとして出版されています。
- ]
-
オンラインで参照できる PostgreSQL の本も2冊あります。 - http://www.postgresql.org/docs/books/awbook.html - -
- [訳注:
- この本は、JPUG「PostgreSQL Book翻訳分科会」
- で翻訳され、ピアソンから
- 「はじめてのPostgreSQL」として出版されています。
- ]
-
- [訳注:
- 邦訳は「実践 PostgreSQL」
- がオライリーから出版されています。
- ]
-
- [訳注:
- 日本語の書籍等については、日本PostgreSQLユーザ会の、http://www.postgresql.jp/PostgreSQL/references.html
- もごらんください。
- ]
-
コマンドラインのクライアントプログラムpsql にも、型、 - 演算子、関数、集約、その他の情報を調べるために、素晴らしい \d コマンド - がいくつかあります。 \? を入力すると利用可能なコマンドが表示されます。
- -我々の Web サイトには、さらに沢山の文書があります。
- -
- [訳注:
- 2008年11月18日、PostgreSQL普及のために一般向けの情報を扱う
- 「Let's Postgres」というポータルサイトがオープンしました。http://lets.postgresql.jp/
- ]
-
まず、 上記で述べた PostgreSQL についての本を読むことを検討してください。 - The Practical SQL Handbook, Bowman Judith S. et al., - Addison-Wesley も多くのユーザに好評です。 ほかでは、The Complete - Reference SQL, Groff et al., McGraw-Hill も好評です。
- - -素晴らしい手引書は、
-
- [訳注:
- 日本PostgreSQLユーザ会の日本語の参考文献の紹介ページ
-
-http://www.postgresql.jp/PostgreSQL/references.html
- があります。
- 堀田倫英氏の「PostgreSQL日本語マニュアル」
- http://www.net-newbie.com/
- ではオンラインマニュアルの検索ができます。
- 丸山不二夫氏のUNIX データベース入門
- http://www.wakhok.ac.jp/DB/DB.html
- もオンラインで読むことができます。
- Nikkei BP IT Pro にある石井達夫氏の PostgreSQL ウォッチ
- では毎回新しい情報をとりあげています。
- ]
-
- （開発者向けの）Developer's FAQをごらんください。
- - -ソフトウェアを評価する方法にはいくつかあります。機能と性能と信頼性と - サポートと価格です。
- -合州国の夏時間の変更は、PostgreSQLのリリース8.0.4以降[4+]と、その - 後のメジャーリリース、たとえば 8.1 には含まれています。カナダとオー - 西部ストラリアの変更は、8.0.[10+], 8.1.[6+] および、その後のメジャー - リリースのすべてに含まれます。8.0より前のPosrgreSQLではオペレーティ - ングシステムのタイムゾーンデータベースを夏時間情報のために使ってい - ます。
- -PostgreSQLのMajordomo - ページから、PostgreSQLに関する複数のメーリングリストの購読の開始と中止 - ができるようになっています。（ログインするためにはMajaordomoから送ら - れる御本人のパスワードが必要になります。）
- -PostgreSQLnoすべてのメーリングリストでは、返信はメーリングリスト - とかつ元のメールの投稿者へ送られるように構成してあります。こ - れにり利用者は、もっとも迅速にメールへの返信を受けられるようになって - います。既に直接受け取っているメールを、リストから重複して受け取りた - くない場合は、Majordomo のChange Settingsページから、 - eliminateccをチェックします。また、selfcopyのチェック - をはずすことで、自分の送ったメールのコピーを受け取らないようにもでき - ます。
- - -PostgreSQL のインストールに含まれる物はCと組込み - Cのインターフェースだけです。その他のインターフェース - は独立したプロジェクトで、別々にダウンロードされます。分かれることで、 - それぞれの開発チームが独自のリリーススケジュールを持つことが許されま - す。
- -PHP のようないくつかのプログラミング言語は、 - PostgreSQLのインターフェースを含んでいます。Perl, TCL, - Python, そして、そのほかの利用可能な言語のインターフェースは、http://pgfoundry.org - の Drivers/Interfaces の節の中とインターネットの検索でみつけ - られます。 -
- - - データベースを裏に持つ Web ページについての素晴らしい紹介が、
- http://www.webreview.comにあります。
Web への拡張のためには、PHP(http://www.php.net/) - が卓越したインターフェースとなっています。
- -
- [訳注:
- PHPに関する日本語の情報は、2000年4月19日に発足した日本PHPユーザ会のサイト
- http://www.php.gr.jp/
- あるいは、廣川 類さんのサイト
- http://www.geocities.jp/rui_hirokawa/php/
- にかなりまとめられています。
- ]
-
処理が複雑な場合、多くの人は Perl インターフェースと CGI.pm か - mod_perl を使います。
- - -商用とオープンソース開発者によるもの両方で、PostgreSQLには多くのGUIツールが利用可能で、詳細なリストは、 -PostgreSQL GUI ツールについてのコミュニティガイド にてごらんください。
- -
- [訳注:
- pgAdmin3 はPostgreSQL標準GUI管理ツールで、Windows版(PostgreSQL
- for Windows) に同梱されています。詳しい情報は、
- http://www.pgadmin.org/にあります。
- ]
-
簡単な方法は、 configure を走らせるときに --prefix オプショ - ンを指定することです。
- - -既定値では、PostgreSQL は Unix ドメインソケット、または、TCP/IP接 - 続のローカルマシンからの接続しか許しません。postgresql.conf の中の - listen_addresses を修正し、かつ、$PGDATA/pg_hba.conf - ファイルを適切に直し、データベースサーバを再起動して、ホストベース - の認証を有効にしないかぎりは、他のマシンからは接続できないでしょう。
- - -性能改善の可能性のありそうな主な領域が3つあります：
-
- [訳注:
- JPUG理事長の片岡裕生氏による、「今すぐできるPostgreSQLチューニング」
- というコーナーが ThinkIT サイトにあり、実作業の参考になります。
- http://www.thinkit.co.jp/free/tech/10/1/1.html
- ]
-
サーバ構成変数については、
-href="http://www.postgresql.org/docs/current/interactive/runtime-config-logging.html">http://www.postgresql.org/docs/current/interactive/runtime-config-logging.html
- に示されるように多くの log_* があり、クエリとプロセス
- の統計情報を出力することができ、デバグや性能測定にはとても便利です。
既定での制限である 100 のデータベースセッションに達してしまって - います。サーバーの同時接続できるバックエンドプロセスの制限値を増やす - 必要があります。postgresql.conf の中のmax_connections - の値を変更してサーバを再起動することで可能になります。
- - -バージョン番号付けの方針について、更新全般についての解説はhttp://www.postgresql.org/support/versioning を、 - そして、アップグレードについての一般的な説明は - http://www.postgresql.org/docs/current/static/install-upgrading.html - をご覧ください。 -
-
-[訳注：
- アップグレードについての和訳版は下記にあります。
- http://www.postgresql.jp/document/current/html/install-upgrading.html
-]
-
-[訳注： - 原文では、下記の内容は独立したページに移され、削除されています。 -- -
新しい機能を盛り込むPostgreSQLのメジャーリリースはだいたい年に1回 - 程度行ないます。メジャーリリースは、たとえば、8.1から8.2へのように、 - バージョン番号の1番目か2番目の部分を増やしてゆきます。
- -PostgreSQLのメジャーリリースは通常、システムテーブルとデータの内 - 部フォーマットを変更します。これらの変更はたいていは複雑なのでで、デー - タファイルの後方互換性を維持したりはしません。メジャーアップグレード - のためには、データベースのダンプ/リロードが必要になります。
- -マイナーリリースは、たとえば、8.1.5 から8.1.6へのように、バージョ - ン番号の3番目の値を増やします。PostgreSQLチームは、マイナーリリース - に対しては、バグフィクスしか行ないません。すべてのユーザは、できるだ - け最新のマイナーリリースに更新すべきです。アップグレードには、常にリ - スクがつきものですから、PostgreSQLのマイナー修正リリースでは、頻繁に - 発生したり、セキュリティに関係したり、データがつぶれるバグだけを修正 - し、アップグレードのリスクを最小限にとどめます。我々のコミュニティで - は、アップグレードするリスクよりも、アップグレードしないリスク - のほうが高いと考えています。
- -マイナーリリースのアップグレードにはダンプとリストアの必要はなく、 - データベースサーバを停止して、アップデートされたバイナリをインストー - ルし、サーバをリスタートします。
--] -- - -
PCハードウェアはほとんど互換性がありますので、ほとんどの人は、す - べてのPCハードウェアが同じ品質だと思い込む傾向があります。しかし、そ - れは間違いです。ECC RAM、SCSI、および、高品質マザーボードは、安いハー - ドウェアに比べると、より信頼性が高く、より性能も良いのです。 - PostgreSQL はほとんどのハードウェアで稼働しますが、信頼性や性能が重 - 要な場合は、使用中のハードウェアのオプションについて調査することが - 賢明です。バッテリーバックアップ付きのキャッシュを持つディスクコント - ローラも役に立ちます。我々のメーリングリスト上でもハードウェアオプショ - ンのトレードオフについて議論することができます。
-取得したいロウがほんの数行で、SELECT の実行時に取得するロウの - 数が分かっていれば LIMIT を使いましょう。インデックスが - ORDER BY とマッチすれば、クエリ全体を(丸ごと)実行しなくても済む場合も - あります。SELECT する時点でロウの数が不明なら、カーソルを使って - FETCH しましょう。 - -
ランダムにロウをSELECTするには、次の文を使います： -
- SELECT col - FROM tab - ORDER BY random() - LIMIT 1; -- - -
psql の中で \dtコマンドを使ってテーブルを見ることができ - ます。psqlの中で \? を使って、コマンドの全リストを調べることができま - す。一方で、psql のソースコードで、バックスラッシュコマンドを - 出力する pgsql/src/bin/psql/describe.c ファイルを読むこともで - きます。その中には、 SQL コマンドを生成する部分も含ま - れます。また、 -E オプションを付けて psql を開始すると、 - 入力されたコマンドを実行するためのクエリを印字出力するようになります。 - PostgreSQLは SQL 準拠の INFORMATION SCHEMA インター - フェースを提供しますので、データベースについての情報を問い合わせるこ - ともできます。
- -pg_ で始まるシステムテーブルでもこれらを記述することができ - ます。
- -psql -lを使うと全てのデータベースをリストします。
- -それと、pgsql/src/tutorial/syscat.source を試してみてくだ - さい。そこには、データベースのシステムテーブルから情報を得るために必 - 要な SELECT 文が沢山あります。
- - -カラムのデータ型の変更は 8.0 以降では、 - ALTER TABLE ALTER COLUMN TYPE を使うことにより間単に - なりました。
- -それより前のバージョンでは、以下のようにします:
-- BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; -- -
これを行なったときは、抹消された行が使っているディスク空間を回収 - するためにVACUUM FULL tabをしたほうが良いかもしれません。
- -制限は以下のとおりです:
--- --
-- データベースの最大サイズ? 制限無し (32 TB のデータベースも存在します) - テーブルの最大サイズ? 32 TB - ロウの最大サイズ? 400 GB - フィールドの最大サイズ? 1 GB - テーブル内での最大ロウ数? 制限無し - テーブル内での最大カラム数? カラムの型によって 250-1600 - テーブル内での最大インデックス数? 制限無し
もちろん、これらは実際は無制限ではなく、ディスク容量とメモリーや - スワップスペースの大きさにより制限されます。性能はこれらの値がことの - ほか大きな時に煽りを受けます。
- -最大テーブルサイズの32TBはオペレーティングシステムによる巨大ファ - イルのサポートは必要としません。巨大なテーブルは複数の1GBのファイル - に分けて保存されますので、ファイルシステムの制限は重要ではありません。 -
- -デフォルトのブロックサイズを32kに増加することで、最大テーブルサイズ - と行サイズと最大カラム数とを4倍にすることができます。また、最大テーブル - サイズはテーブルパーティションを使って増やすこともできます。
- -ひとつの制限は、約2,000文字以上の長さのカラムにインデックスを付 - けることができないことです。 幸いにも、そのようなインデックスは実際 - は必要ありません。長いカラムのMD5ハッシュの関数インデックスは一意性 - がなによりの保険で、また、フルテキストのインデックスではカラム内の - 単語を検索することができます。
- -普通のテキストファイルを PostgreSQL のデータベースに保存するには、 - 最大で約5倍のディスク容量を必要とします。
- - -例題として、各行に整数とテキスト記述を持つ 100,000行のファイルを - 考えてみましょう。テキストの文字列の平均長さを20バイトと仮定すると、 - フラットファイルの大きさは約2.8MB です。このデータを含む PostgreSQL - データベースファイルの大きさは次のように約5.2MBと見積もることができ - ます： - -
- 24 bytes: 各ロウのヘッダ(概算) - 24 bytes: 整数(int)フィールドとテキスト(text)フィールド - + 4 bytes: ページ上のタップルへのポインタ - ---------------------------------------- - 52 bytes per row - - PostgreSQL のデータページサイズは 8192バイト(8KB)なので: - - 8192 bytes per page - ------------------- = 146 rows per database page (切り捨て) - 52 bytes per row - - 100000 data rows - -------------------- = 633 database pages (切り上げ) - 158 rows per page - - 633 database pages * 8192 bytes per page = 5,185,536 bytes (5.2 MB) -- -
インデックスは、これほどのオーバヘッドは要求しませんが、インデッ - クス付けされるデータを含む以上、それなりに大きくなります。
-NULLはビットマップとして保存されていて、それらがわ - ずかにスペースを使います。
- - -インデックスは、すべてのクエリで使われるわけではありません。テー - ブルが最小サイズより大きく、クエリでそのわずかなパーセンテージのロウ - を選択する時だけ、インデックスは使われます。これはインデックススキャ - ンにより起こされるランダムなディスクアクセスは、テーブルをストレート - に読む順次走査よりも遅くなることがあるからです。
- -インデックスを使うかを決定するために、PostgreSQL はテーブルについ - ての統計情報を持たなければなりません。この統計情報は、 - VACUUM ANALYZEまたは、単に ANALYZE を使っ - て収集することができます。統計情報を使ってオプティマイザはテーブルの - 中にあるロウ数を知り、インデックスを使うべきかの決定をより正しくでき - ます。統計情報は最適な結合順や結合方法を決める上でも貴重なものもあり - ます。統計情報の収集は、テーブルの内容が変わる毎に繰返しなされるべ - きです。
- -インデックスは、通常 ORDER BY や結合を行なうため - には使われません。順次スキャンに続く明示的ソートは、巨大なテーブルの - インデックススキャンよりも普通は高速です。
- - しかし、ORDER BYと組み合わされたLIMIT - は、テーブルの小さな部分を返すためにたびたびインデックスを使うでしょ - う。 - -もし、オプティマイザが間違ってシーケンシャルスキャンを選択したこ
- とに疑いがなければ、SET enable_seqscan TO 'off'に設定し
- て、クエリをもう一度実行し、インデックススキャンがまちがいなく速くなっ
- ているかどうかをみてください。
LIKE あるいは ~ のようなワイルドカード演算 - 子は特別な環境でしか使えません： -
LIKEイン - デクシングにだけ働くような、特別な
text_pattern_opsイ - ンデックスを作成することもできます。また、それを全文検索のフル - テキストのインデックス作成に使うことができます。 -
- - -
オンラインマニュアルで EXPLAIN を見てください。
- -~演算子は正規表現照合を行ない、~* は大文字と小文字 - を区別しない(case-insensitive)正規表現照合を行います。 大文字と小文 - 字を区別しない LIKE 演算子を ILIKE と - いいます。
- -大文字と小文字を区別しない等値比較は次のように表現できる： -
- SELECT * - FROM tab - WHERE lower(col) = 'abc'; -- -
標準インデックスでは使われず、しかしながら、もし、式インデックス - を作ったならそれが使われるでしょう。
- -- CREATE INDEX tabindex ON tab (lower(col)); -- -
上記のインデックスがUNIQUEで作成された場合、カラム - は大文字と小文字を格納できますが、その違いが文字ケースだけであっても - 同一にはなりません。あえて特定の文字ケースをカラムに格納するには - CHECK制約か、トリガーを使ってください。
- - - -以下のように、IS NULL と IS NOT - NULLで、そのカラムをテストしてみます：
- -- SELECT * - FROM tab - WHERE col IS NULL; -- -NULLの可能性のあるものを連結するには、COALESCE()を -次のように使います。 - -
- SELECT COALESCE(col1, '') || COALESCE(col2, '') - FROM tab -- -
NULL状態でソートするには、IS NULL と - IS NOT NULL の修飾子を ORDER BY 句の中 - で使ってみます。true のものは false のものよりも高い値 - として並べられますので、次の例では NULL の記載が結果リストの上部に置 - かれます。 - -
- SELECT * - FROM tab - ORDER BY (col IS NOT NULL) -- - -
-- --
-- 型 内部名 備考 - VARCHAR(n) varchar 最大長のサイズを指定する、詰め物無し - CHAR(n) bpchar 指定された固定長となるように空白が詰められる - TEXT text 長さに特別な上限は無し - BYTEA bytea 可変長のバイト配列(null-byte safe) - "char" char 1文字
内部名にお目にかかるのは、システム・カタログを調べるときや、エラー - メッセージを受け取るときです。
- -上記の型のうち最初の４つの型は "varlena" 型です(すなわち、ディス - クの最初の４バイトがデータ長で、それの後に実際のデータが続きます)。 - このように実際の空間は宣言された大きさよりも少し大きくなります。しか - し、長い値は圧縮されるので、ディスク上の空間は思ったよりも小さくなります。
- -VARCHAR(n) は可変長の文字列を保存するのに最適です - が、保存できる文字列の長さに制限があります。TEXT は長 - さに制限の無い文字列の保存のためのもので、最大で 1ギガバイトです。 - CHAR(n)は、VARCHAR(n)が与えられた文字 - だけを保存するのに対し、ブランクを詰め込んでいつも同じ長さで文字列を - 保存するのに最適です。BYTEAは、部分的に - NULL のバイトを含むバイナリデータを保存するためのもの - です。これらのタイプは同じくらいの性能特性をもちます。
- - -PostgreSQL は SERIAL データ型をサポートします。カ - ラム上にシーケンスを自動作成します。たとえば、
- -- CREATE TABLE person ( - id SERIAL, - name TEXT - ); -- は自動的に次のように翻訳されます: -
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
-
-
-
- [訳注：
- CREATE UNIQUE INDEX person_id_key ON person ( id );
- は、 7.3 以降は自動的には行なわれなくなりました。
- ]
-
自動的につくられる通番は、 - <table>_<serialcolumn>_seq - と名付けられていて、table と serialcolumn は、それぞれ - テーブルと SERIAL カラムの名前です。 - 通番については、オンラインマニュアルでcreate_sequence - をごらんください。
- - -最も簡単な方法は、割り当てられたSERIAL値を - RETURNINGとして取得することです。 - 4.11.1の例題テーブルを使うと次のように - なります。 - -
- INSERT INTO person (name) VALUES ('Blaise Pascal') RETURNING id;
-
-
-
-それはありません。currval() は、すべてのユーザではありませ - んが、読者のセッションに与えられた現在の値を返します。
- - -同時性を改善するために、実行中のトランザクションに、必要に応じてト - ランザクションが終了するまでロックされないようシーケンス値を与えてい - ます。このためトランザクションが中断されると番号割り当てにギャップを - 生じます。
- - -テーブルがWITH OIDSでつくられた場合は、それぞれの - ロウに一意なOIDが取られます。 - OIDは自動的に4バイトの整数で与えられ、それは、全イン - ストレーションを通して一意な値となります。しかし、約40億でオーバーフ - ローし、そして、OIDは重複をしはじめます。PostgreSQLは - 内部システムテーブルを一緒にリンクするためにOID を使 - います。 - -
ユーザのテーブルのカラムに一意の番号を付けるためには、 - OID ではなく SERIAL を使うのが最もよい - でしょう。SERIALの連番は1つのテーブル内でのみ一意にな - るからで、オーバーフローを起こしにくいと考えられます。 - 8バイトのシーケンス値を保存するために、SERIAL8があり - ます。
- -CTID は、特定の物理ロウをブロックとオフセットの値 - で識別するために使われます。CTIDは、ロウが修正された - り再読込みされたときに変わります。また、物理ロウを差すためにインデッ - クスの記載に使われます。
- - -おそらく、システムの仮想メモリーを全て使い果たしてしまっている可 - 能性があるか、カーネルがあるリソースについてもつ制限値が低すぎる可能 - 性があります。サーバを始動する前にこれを試してみてください：
- -- ulimit -d 262144 - limit datasize 256m -- - シェルによって、どちらかひとつが成功するでしょうが、これはプロセスの - データセグメント制限をより高く設定し、たぶんクエリが完結するようにな - るでしょう。このコマンドは現行のプロセスと、このコマンドを走らせた後 - に作られる全てのサブプロセスについて適用されます。バックエンドがとて - も多くのデータを返すためにSQL クライアントで問題が続 - いているのであれば、クライアントを開始する前にこれを試してみてくださ - い。 - -
psql から SELECT version(); をタイプします。
CURRENT_TIMESTAMPを使います:
-- CREATE TABLE test (x int, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- - -
PostgreSQL は SQL 標準構文を使う外部結合(アウタージョイン)をサポー - トします。ここに 2つの例題があります。
- -- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); --あるいは -
- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- -これらの象徴的なクエリでは t1.col を t2.col と結合して、t1 の結合されなかったロウ(t2 と一致しなかったロウ)も返しています。RIGHT 結合は t2 の結合されなかったロウを加えるでしょう。FULL 結合は、一致したロウに t1 と t2 からは結合されなかったロウを返すでしょう。OUTER という言葉はオプションで LEFT, RIGHT, または FULL などの結合を仮定されています。通常、結合はINNER結合と呼ばれます。 - - -
現行のデータベース以外への問い合わせの方法はありません。というの - もPostgreSQLがデータベース仕様のシステムカタログを読み込むためで、そ - こには、たとえそのふりをするだけにしろ、データベースを越えて問い合わ - せをするすべがありません。
- -contrib/dblink はデータベース間(cross-database)の問い合わ - せを関数呼出しにより許します。もちろん、クライアントは同時に接続を別 - のデータベースへも張らなくてはならず、結果をクライアント側でマージし - なくてはなりません。
- - -集合を返す関数(Set Returning Functions): - - http://wiki.postgresql.org/wiki/Return_more_than_one_row_of_data_from_PL/pgSQL_functions - を使うと簡単です
。 - - -バージョン8.3より前の PostgreSQL では、PL/PgSQL は関数スクリプトを - キャッシュしたため、運悪くその副作用がありました。PL/PgSQL 関数が一時 - テーブルにアクセスして後でそのテーブルを消して作りした場合に、関数が - もう一度呼び出されたときは、その関数のキャッシュしていた内容がまだ古い - 一時テーブルを指し示したままだったからです。 - この、解決策として、PL/PgSQLの中で EXECUTE を一時テー - ブルへのアクセスのために使います。そうすると、クエリは毎回パースをや - り直しされるようになります。
- -この問題は、 PostgreSQL バージョン8.3 以降では起きません。
- - -「レプリケーション」と一言でいいますが、レプリケーションをする - ための技術はいくつかあり、それぞれ、利点と欠点があります。
- -マスタ／スレーブのレプリケーションは、読み／書きのクエリを受け取 - るシングルマスタが可能で、スレーブでは 読み／SELECTの - 問い合わせだけを受け付けることができます。最も人気がある、フリーで利 - 用できる、マスタ−スレーブのPostgreSQLレプリケーションソリューション - は、 - Slony-I です。
- -マルチ−マスタのレプリケーションは、読み／書きのクエリを受けと - り、複数のレプリケートさせるコンピュータに送ることができます。この機 - 能は、サーバ間の変更の同期が必要なため、性能に重大な衝撃を与えます。 - PGCluster は、 - このようなソリューションとしてPostgreSQLのためにフリーで利用できるも - のとして、最も人気があります。
- -この他にも、商用やハードウェア−ベースのレプリケーションソリュー - ションがいろいろなレプリケーションモデルをサポートしています。
- -名前が認識されない、最も一般的な原因は、テーブルを作成する際に、 - テーブルやカラムを囲う二重引用符の使用です。 - 二重引用符を使うと、テーブルとカラムの名前（識別子といいます）は大文字と小文字の区別 - をして格納されます。したがって、pgAdminのようにテーブル作成のときに - 自動的に二重引用符を使うものはクエリの中でそれらの名前を使うときに - 二重引用符を付けなくてはならないことを意味します。このため、識別子 - を認識させるためには以下のいずれかを心がけます。 - -
createdb -Eコマンドオプションに UTF8 あるいは EUC_JP - のエンコーディングを指定してデータベースを作成するか、次のように - エンコーディングを指定してデータベースを作成してください。
-- CREATE DATABASE dbname WITH ENCODING 'UTF8'; - もしくは、 - CREATE DATABASE dbname WITH ENCODING 'EUC_JP'; -- - -
psqlの中でクライアントのエンコーディングを指定してください。
-- SET client_encoding TO 'SJIS' --
PostgreSQLデータベースのエンコーディングに使える日本語文字コード - は EUC_JP か UTF-8(UNICODE) であるため、Shift-JIS表示のコマンドプロ - ンプトからは、client_encodingを設定しておかないと、日本語を表示する - 際に文字化けがおきます。
- - -バージョン8.3では、TSearch2全文検索機能が本体に組み込まれ - ましたが、そのままでは日本語のインデックスを作る事が難しい状況です。 - これを解決するために、Takahiro Itagaki氏によって、Mecabという形態素 - 解析プログラムを利用する日本語全文検索モジュール textsearch_ja - が開発されました。TSearch2対応の製品をわずかに改修することで日本語対 - 応にきます。 -
- -
-[訳注：
- 日本語版の製作については以下の通りです。
-
- 最終更新日: 2008年10月8日
- 翻訳者: 桑村 潤 (Jun KUWAMURA <juk at postgresql.jp>)
-
- このFAQの和訳の作成にあたり協力をしてくださった方々(敬称は略させていただきます):
-
- 田仲 稔(Minoru TANAKA <Tanaka.Minoru at keiken.co.jp>)
- 石井 達夫(Tatsuo ISHII <ishii at sraoss.co.jp>)
- 齊藤 知人(Tomohito SAITOH <tomos at elelab.nsc.co.jp>)
- 馬場 肇(Hajime BABA <baba at kusastro.kyoto-u.ac.jp>)
- 岡本 一幸(Kazuyuki OKAMOTO <kaz-okamoto at hitachi-system.co.jp>)
- 小菅 昭一(Shoichi Kosuge <s-kosuge at str.hitachi.co.jp>)
- 山下 義之(Yoshiyuki YAMASHITA <dica at eurus.dti.ne.jp>)
- 境 真太郎(Sintaro SAKAI <s_sakai at mxn.mesh.ne.jp>)
- 生越 昌己(Masami OGOSHI <ogochan at zetabits.com>)
- 石川 俊行(Toshiyuki ISHIKAWA <tosiyuki at gol.com>)
- 本田 茂広(Shigehiro HONDA <fwif0083 at mb.infoweb.ne.jp>)
- せせ じゅん(Jun SESE <sesejun at linet.gr.jp>)
- 神谷 英孝(Hidetaka KAMIYA <hkamiya at catvmics.ne.jp>)
- 菅原 敦(Atsushi SUGAWARA <asugawar at f3.dion.ne.jp>)
- 稲葉 香理(Kaori Inaba <i-kaori at sraoss.co.jp>)
- 芳賀 靖史(Yasufumi Haga <yasufumi.haga at nifty.com>)
-
- をはじめ、ポストグレスに関する話題豊富な日本語PostgreSQLメーリングリスト、
- 和訳のきっかけを作ってくれたり、いつもチェックをしてくれる
- JF(Linux Japanese FAQ)プロジェクト、FreeBSD ドキュメンテーションプロジェクト
- の方々、それから、直接あるいは間接的にかかわってくださるすべてのオープンソース
- コミュニティのみなさまに感謝いたします。
-
-
- この翻訳文書は 本家 "Frequently Asked Questions" のページに "Japanese FAQ"
- という項目であります。
-
- また、最新版は以下のサイトにあります。
- http://www.postgresql.jp/wg/jpugdoc/ 「JPUG文書・書籍関連分科会」
- http://www.linux.or.jp/JF/JFdocs/INDEX-database.html 「Linux JFプロジェクト」 http://www.linet.gr.jp/~juk/pgsql/ 「PostgreSQL Notes for Japanese」（翻訳者ページ）
-
- なお、この和訳に関するご意見・ご質問は(juk at postgresql.jp)までお寄せください。
- （※ メールアドレスの " at " は適切に直してください。半角の "@" です。）
-]
-
Ostatnia aktualizacja: Sobota Luty 7 22:16:21 EST 2004
- -Ostatnia aktualizacja tłumaczenia: Piątek Marzec 5 19:31:12 EST 2004
- -Obecny maintainer: Bruce Momjian (pgman@candle.pha.pa.us)
-
Tłumaczenie: Marcin Mazurek (m.mazurek@netsync.pl)
-
Najbardziej aktualną wersję tego dokumentu można znaleźć pod - adresem: - http://www.PostgreSQL.org/docs/faqs/FAQ.html.
- -Odpowiedzi na pytania dotyczące konkretnych systemów operacyjnych - można znaleźć pod adresem: - http://www.PostgreSQL.org/docs/index.html.
-IN są takie wolne?PostgreSQL wymawia się Post-Gres-kju-el. Często podczas - rozmów używany jest termin "Postgres"
- -PostgreSQL jest rozszerzeniem systemu zarządzania bazami danych - - POSTGRES, kolejną generacją rozwojowego prototypu DBMS. - Mimo, że PostgreSQL zachował bardzo dobrze zbudowany model danych - (data model) i bogaty zestaw typów danych POSTGRES'a, zastąpił - PostQuel'owy język zapytań z rozbudowanym podzbiorem języka - SQL. PostgreSQL jest oprogramowaniem darmowym - z dostępnymi całymi źródłami. -
- -Rozwój PostgreSQL jest prowadzony przez grupę ludzi z Internetu, - komunikujących się poprzez mailowe listy dyskusyjne PostgreSQL. - Obecnym koordynatorem jest Marc G. Fournier (scrappy@PostgreSQL.org). (Zobacz - pytanie 1.6 jak się przyłączyć). Ta grupa ludzi jest - odpowiedzialna za cały rozwój PostgreSQL. PostgreSQL jest projektem - nie kontrolowanym przez żadną firmę, aby wziąć udział w jego rozwoju - sprawdź, - http://www.PostgreSQL.org/docs/faqs/FAQ_DEV.html
- -Autorami PostgreSQL 1.01 byli Andrew Yu and Jolly Chen. - Wiele innych osób pomogło przy portowaniu, testowaniu, debugowaniu i - rozwijaniu kodu. Oryginalny kod Postgresa, na którym został oparty - PostgreSQL, był wysiłkiem studentów oraz pracowników pracujących pod - kierownictwem profesora Michael'a Stonebraker'a z University of - California w Berkeley.
- -Oryginalną nazwą oprogramowania w Berkeley był Postgres. Po - dodaniu obsługi SQL w 1995, nazwa została zmieniona - na Postgres95. Pod koniec roku 1996 nazwa została zmieniona na - PostgreSQL.
- -PostgreSQL objęty jest następującą licencją:
- -PostgreSQL Data Base Management System
- -Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-6 Regents of the University of California
- -Permission to use, copy, modify, and distribute this software - and its documentation for any purpose, without fee, and without a - written agreement is hereby granted, provided that the above - copyright notice and this paragraph and the following two - paragraphs appear in all copies.
- -IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL - DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS - SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF - CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- -THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE - SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE - UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, - SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- -Tekst powyżej, jest klasyczną licencją BSD. - Nie posiada ona żadnych restrykcji co do używania kodu źródłowego. - Podoba nam się i nie zamierzamy jej zmieniać.
- -PostgreSQL powinien działać na wszystkich nowych Unix-podobnych - systemach. Platformy, które zostały szczegółowo przetestowane podczas - publikowania PostgreSQL są wymienione w dokumentacji opisującej - instalację.
- -Klient
- -Możliwa jest kompilacja bibliteki C libpq, psql oraz - innych interfejsów i uruchamianie ich na platformie MS Windows. W tym - wypadku klient jest uruchamiany na MS Windows a z serwerem komunikuje się - poprzez TCP/IP. Serwer może działać na dowolnej wspieranej platformie - Unixowej. Plik win32.mak jest dołączony - do źródeł, aby można było stworzyć bibliotekę libpq oraz - program psql działające w środowisku Win32. PostgreSQL może się - także komunikować z klientami ODBC.
- -Serwer
- -Serwer może być uruchamiany na Windows NT i Win2k używając - bibliotek Cygwin, Cygnus Unix/NT. W pliku pgsql/doc/FAQ_MSWIN - znajdującym się w źródłach lub pod adresem: http://www.PostgreSQL.org/docs/faqs/text/FAQ_MSWIN na naszych stronach.
- Obecnie prowadzone są prace nad stworzeniem wersji dla MS Win - NT/200/XP. Jeśli chcesz się dowiedzieć o obecnym statusie tych prac - zobacz http://techdocs.postgresql.org/guides/Windows and - http://momjian.postgresql.org/main/writings/pgsql/win32.html. -
-- Istnieje także port pod Novell Netware 6 dostępny pod adresem http://forge.novell.com. -
- -Główny serwer ftp z dostępem "anonymous" dla PostgreSQL znajduje - się ftp://ftp.PostgreSQL.org/pub. - jeśli szukasz mirrorów sprawdź naszą główną stronę www.
- -Adres głównej listy mailowej: pgsql-general@PostgreSQL.org. - Jest ona przeznaczona dyskusjom dotyczącym spraw związanych z PostgreSQL. - Żeby zapisac się na listę, wyślij email z następującymi liniami w - treści maila (nie w temacie):
-- subscribe - end -- -
na adres: pgsql-general-request@PostgreSQL.org.
- -Dostępna jest także lista wysyłająca digesty. Aby zapisać się na - nią, wyślij email na adres: - pgsql-general-digest-request@PostgreSQL.org - z treścią maila zawierającą:
-- subscribe - end -- Digesty są wysyłane do członków listy, kiedy na główną listę dotrze ok - 30k wiadomości. - -
Dostępna jest także lista poświęcona błędom znalezionym w - PostgreSQL. Aby zapisać się na nią wyślij email na adres: - pgsql-bugs-request@PostgreSQL.org - z treścią maila zawierającą:
-- subscribe - end -- Lista poświęcona dyskusjom developerów jest dostępna pod adresem: - pgsql-hackers-request@PostgreSQL.org - Aby się na nią zapisać wyślij na jej adres mail z treścią: -
- subscribe - end -- -
Dodatkowe informacje o listach mailowych dotyczących PostgreSQL - można znaleźć na stronach WWW PostgreSQL pod adresem:
- -- -- -
W sieci EFNet istnieje kanał IRC #PostgreSQL. Ja, do
- połączenia się z kanałem używam Unixowego polecenia irc -c
- '#PostgreSQL' "$USER" irc.phoenix.net.
Lista firm oferujących wsparcie na zasadach komercyjnych znajduje - się pod adresem: http://techdocs.postgresql.org/companies.php.
- -Ostatnia dostępna wersja PostgreSQL to 7.4.1.
- -Planujemy publikowanie kolejnych wersji co sześć do ośmiu miesięcy.
- -Kilka manuali, stron podęcznika man, oraz kilka przykładów do - testowania są załączone w samej dystrybucji. Znajdują się one w - katalogu /doc. Manual może być także przeglądany poprzez - strony www pod adresem http://www.PostgreSQL.org/docs.
- -Istnieją także dwie książki dostępne online pod adresami - http://www.PostgreSQL.org/docs/awbook.html - i http://www.commandprompt.com/ppbook/. - Lista książek o PostgreSQL, które można kupić znajduje się pod adresem - - http://techdocs.PostgreSQL.org/techdocs/bookreviews.php. - Zbiór technicznych artykułów o PostgreSQL znajduje się pod adresem http://techdocs.postgresql.org/.
- -psql posiada kilka wbudowanych poleceń \d, za pomoca których - można sprawdzić informacje dotyczące typów, operatorów, funkcji, - agregatów itd.
- -Na naszej stronie można znaleźć dużo więcej dokumentacji.
- -PostgreSQL wspiera rozszerzony podzbiór standardu SQL-92. - Sprawdź naszą listę TODO - aby znaleźć informację o znanych problemach, brakujących - rozwiązaniach czy przyszłych planach.
- -Książka o PostgreSQL http://www.PostgreSQL.org/docs/awbook.html - uczy SQL. Jest jeszcze inna ksiązka o PostgreSQL - dostępna pod adresem: http://www.commandprompt.com/ppbook. - Dobry tutorial możesz znaleźć pod adresem: http://www.intermedia.net/support/sql/sqltut.shtm, - oraz - http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM, - i http://sqlcourse.com.
- -Jeszcze inny to "Teach Yourself SQL in 21 Days, Second Edition" - pod adresem: http://members.tripod.com/er4ebus/sql/index.htm
- -Wielu z naszych użytkowników poleca The Practical SQL Handbook, - Bowman, Judith S., et al., Addison-Wesley. Inni polecają The - Complete Reference SQL, Groff et al., McGraw-Hill.
- -Tak, bez problemu radzimy sobie z datami po roku 2000 AD, oraz - przed rokiem 2000 BC.
- -Przede wszystkim ściągnij ostatnie dostępne źródła i przeczytaj - dokumentację przeznaczoną dla developerów na naszej stronie www lub - dostępną także w źródłach PostgreSQL. Następnie zapisz się na listy - mailowe pgsql-hackers i - pgsql-patches. I na koniec, wysyłaj nam wysokiej jakości - patch'e na listę pgsql-patches.
- -Jest około 12 osób, które mają uprawnienia do commit'owania w - CVS PostgreSQL'a. Każdy z nich submitował tak wiele - wysokiej jakości patchy, że stało się niemożliwe dla obecnych - commiterów być z nimi na bieżąco, więc musieliśmy im ufać i mieć - pewność, że ich poprawki są wysokiej jakości.
- -Zajrzyj na stronę PostgreSQL BugTool, na - której opisane są wskazówki jak zgłaszać informacje o błędach.
- -Zajrzyj także na nasz ftp ftp://ftp.PostgreSQL.org/pub, aby - sprawdzić czy nie ma nowszych wersji PostgreSQL czy patchy.
- -Jest kilka sposobów oceny softwaru: możliwości, - wydajność, stabilność, wsparcie i cena.
- -PostgreSQL korzysta z najlepszej infrastruktury od samego początku - istnienia projektu, czyli roku 1996 kiedy rozpoczeliśmy pracę. Wszystko - to zawdzięczamy Marc'owi Fournier'owi, który stworzył tą infrastrukturę - i zarządza nią od lat.
- -Wysokiej jakości infrastruktura jest bardzo ważna dla każdego - projektu open-source. Zapobiega przerwom w rozwoju projektu i - jakimkolwiek przestojom.
- -Oczywiście korzystanie z wysokiej jakości infrastruktury nie jest - tanie. Istnieje wiele różnych miesięcznych, czy jednorazowych - wydatków, które trzeba ponosić aby wszystko działało jak należy. - Jeśli Ty, bądź Twoja firma może wspomóc finansowo rozwój PostgreSQL - odwiedź adres: http://store.pgsql.com/shopping/ - gdzie opisane jest jak to zrobić.
- -Chociaż na stronie wspomniana jest nazwa PostgreSQL Inc, "datki" - są przeznaczone jedynie na rozwój projektu PostgreSQL i nie są - przeznaczane na finansowanie jakiejkolwiek firmy. Jeśli wolisz, - możesz wysłać czek na adres kontaktowy.
-Dostępne są dwa driwery ODBC: PsqlODBC - i OpenLink ODBC.
- -Możesz pobrać PsqlODBC z adresu http://gborg.postgresql.org/project/psqlodbc/projdisplay.php -
- -OpenLink ODBC może być pobrany z adresu: http://www.openlinksw.com. - Współpracuje ze standardowym oprogramowaniem klienckim ODBC - więc w ten sposób możesz korzystać z PostgreSQL ODBC - dostępnego na każdej pltaformie którą wspiera (Win, Mac, Unix, VMS).
- -Autorzy będą prawdopodobnie sprzedawać ten produkt osobom które - wymagają komercyjnego wsparcia, ale wersja darmowa będzie zawsze - dostępna. Wszystkie pytania możesz wysyłać na adres: postgres95@openlink.co.uk.
- -Dobry podręcznik dla początkujących o dostępie do bazy danych - przez www możesz znaleźć pod adresem: - http://www.webreview.com
- -Do integracji z www, świetnym rozwiązaniem jest PHP. Możesz - znaleźć więcej informacji na ten temat pod adresem - http://www.php.net.
- -Wiele osób w przypadku skomplikowanych rozwiązań uzywa Perl'a i - modułu CGI.pl lub mod_perl.
- -Tak, istnieje kilka interfejsów graficznych dla PostgreSQL. - Wśród nich PgAccess ( - http://www.pgaccess.org), PgAdmin III (http://www.pgadmin.org), - RHDB Admin (http://sources.redhat.com/rhdb/ ) oraz Rekall ( - http://www.thekompany.com/products/rekall/, komercyjny). Istnieje - także PHPPgAdmin ( http://phppgadmin.sourceforge.net/ ), webowy - interfejs dla PostgreSQL. -
-- Więcej informacji na ten temat znajduje się pod adresem See - http://techdocs.postgresql.org/guides/GUITools.
- -Najbardziej popularne języki posiiadają własny interfejs dla - PostgreSQL. Sprawdź listę rozszerzeń dla intersującego Ciebie języka - programowania.
- -Ze źródłami PostreSQL dystrubuowane są interfejsy dla - następujących języków programowania:
- - -Użyj opcji --prefix podczas uruchamiania skryptu - configure.
- -Ten błąd może być wynikiem wielu problemów, ale na początek - sprawdź czy masz zainstalowane rozszerzenia systemu V w jądrze - systemu. PostgreSQL wymaga do pracy zainstalowanej obsługi pamięci - dzielonej i semaforów.
- -Albo nie masz poprawnie skonfigurowanej obsługi pamięci dzielonej - w jądrze systemu, albo musisz zwiększyć jej dostępny rozmiar. - Dokładna ilość jaką potrzebujesz jest zależna od architektury systemu - na jakim pracujesz, jak dużo buforów oraz jak dużo procesów backendu - skonfigurowałeś dla postmaster'a. Dla większości systemów, z - domyślną liczbą buforów i procesów potrzebujesz minimum w - przybliżeniu 1MB. Zobacz PostgreSQL - Administrator's Guide gdzie szczegółowo zostało opisane - wykorzystanie pamięci dzielonej i semaforów.
- -Jeśli treść błędu brzmi: IpcSemaphoreCreate: semget failed - (No space left on device) oznacza to, że jądro systemu nie jest - skonfigurowane do obsługi wystarczającej liczby semaforów. - Postgres wymaga jednego semafor'a na potencjalny jeden proces backend. - Tymczasowym rozwiązaniem jest uruchomienie programu postmaster - z mniejszą maksymalną liczbą procesów backend. - Użyj opcji -N z parameterem mniejszym od domyślnego - 32. - Bardziej trwałym rozwiązaniem jest zwiększenie parametrów - SEMMNS i SEMMNI jądra twojego systemu.
- -Niedziałające semafory mogą spowodować niepoprawne zamknięcie - systemu w czasie intensywnego korzystania z bazy.
- -Jeśli treść błędu jest inna, może to oznaczać, że obsługa semaforów - nie została włączona do jądra wcale. Zobacz PostgreSQL - Administrator's Guide po bardziej szczegółowe informacje o pamięci - dzielonej i semaforach.
- -Domyślnie PostgreSQL pozwala jedynie na połączenia za pomocą - socketów Unixowych z lokalnego hosta. Inne hosty nie będą mogły się - połączyć z serwerem dopóki nie zostanie dodana opcja -i do - postmaster'a, - oraz nie umożliwi się autoryzacji na podstawie adresu hostów - modyfikując odpowiednio plik - $PGDATA/pg_hba.conf. To zmiany pozwolą na połączenia TCP/IP.
- -Indeksy bez wątpienia mogą przyspieszyć wykonywanie zapytań. - Polecenie EXPLAIN pozwala zobaczyć jak PostgreSQL - interpretuje Twoje zapytanie i które indeksy są używane.
- -Jeśli wykonujesz bardzo dużo INSERTów, może warto - je wykonać za pomocą jednego dużego pliku używając polecenia - COPY. Jest to dużo szybsze niż pojedyncze - INSERTy. Po drugie polecenia SQL nie zawarte w bloku - określającym transakcję - BEGIN WORK/COMMIT, są - traktowane jako pojedyncza transakcja. Rozważ wykonanie kilku - poleceń/zdań SQL w jednym bloku transakcji. To redukuje narzut - nakładany przez transakcję. Przy dużych zmianach w danych, warto - usunąć i stworzyć na nowo indeksy.
- -Jest kilka opcji pozwalających na poprawienie wydajności. - Możesz wyłączyć fsync() poprzez uruchomienie postmaster'a - z opcjami -o -F. To spowoduje, że - fsync() nie będzie zrzucał danych na dysk po każdej - transakcji.
- -Możesz także uruchomić postmaster'a z opcją -B - aby zwiększyć wielkość pamięci dzielonej używanej przez procesy - backendów. Jeśli ustawisz tą wartość zbyt wysoko i przekroczysz limity - ustawione przez kernel na pamięć dzieloną, postmaster może się - nie uruchomić. Każdy bufor zajmuje 8K a domyślna ilość buforów to 64.
- -Możesz także użyć opcji -S dla backendu aby zwiększyć - maksymalną wartość pamięci używaną przez proces backendu podczas - sortowania. Opcja -S jest ustawiana wartością podawaną w - kilobajtach, domyślna wartość to 512K.
- -Możesz także użyć polecenia CLUSTER aby pogrupować - dane w tabelach wg indeksu. Zobacz opis polecenia CLUSTER - w manualu żeby dowiedzieć się więcej.
- -PostgreSQL ma kilka możliwości na raportowanie informacji o - jego statusie, które mogą być przydatne przy debugowaniu procesu.
- -Przede wszystkim uruchom skrypt configure z opcją - --enable-cassert, wiele funkcji assert() monitorują postęp - procesu backend i zatrzymują program kiedy wydarzy się coś - nieoczekiwanego.
- -Zarówno postmaster jak i postgres mają kilka opcji - do debugowania. Za każdym razem kiedy uruchamiasz postmaster'a, - upewnij się, że wysyłasz standardowe wyjście i error do pliku z - logami, np. w ten sposób:
-- cd /usr/local/pgsql - ./bin/postmaster >server.log 2>&1 & -- -
To utworzy plik server.log w głównym katalogu PostgreSQL. - Ten plik zawiera pożyteczne informacje o problemach i błędach, które - wydarzyły się podczas pracy serwera. Postmaster posiada opcję - -d, która pozwala na raportowanie bardzo szczególowych - informacji. Do opcji -d podajemy liczbę, która określa - szczegółowość wysyłanych informacji. Musisz mieć świadomość, że - wysoki poziom logowania będzie powodował tworzenie bardzo duzych - plików z logami.
- -Jeśli postmaster nie został uruchomiony, możesz uruchomić - postgres'owy backend z linii poleceń, i uruchomić Twoje - polecenie SQL bezpośrednio na nim. - Taki sposób jest polecany jedynie w przypadku debugowania. - Zwróć uwagę, że w tym wypadku zapytanie kończy znak nowej linii a nie - średnik. Jeśli skompilowałeś z opcjami debugowania mozesz użyć - debuggera aby sprawdzić co się dzieje. Poniewż backend nie został - uruchomiony przez postmaster'a, nie działa w identycznym - środowisku, co oznacza że powtórzenie warunków w jakich wystąpiły - problemy moze być problemem.
- -Jeśli postmaster działa, uruchom psql w jednym z - okien, następnie znajdź PID procesu postgres - używanego przez psql. Użyj debuggera aby do - PID'u postgres'a. Możesz ustawiać pułapki - (breakpoints) w debuggerze i wykonywać zapytania z psql. - Jeśli debugujesz uruchamianie postgres'a, możesz ustawić zmienną - PGOPTIONS="-W n", następnie uruchomić psql. - Opcja ta pozwoli spowolnić uruchomienie na - n sekund abyś mógł się połączyć z procesem za pomocą - debugera, ustawić jakiekolwiek pułapki i kontynuować proces - uruchamiania.
- -postgres może być uruchamiany z opcjami -s, -A i - -t, które mogą być bardzo przydatne przy debuggowaniu i ocenie - wydajności.
- -Możesz także skompilować z profilingiem aby zobaczyć jakie funkcje - ile czasu wykonują się. Pliki profilowane dla backendu zostaną - umieszczone w katalogu - pgsql/data/base/dbname. Pliki profilu klienta zostaną - umieszczone w bieżącym katalogu klienta. Linux wymaga aby kompilować - z opcją -DLINUX_PROFILE aby profilowanie odbywało się - poprawnie.
- -Musisz zwiększyć limit ilości jednoczesnych procesów bacekendu - dla procesu postmaster'a.
- -Domyślny limit to 32 procesy. Możesz go zwiększyć przez restart - postmaster z odpowiednią wartością ustawianą opcję -N w - pliku postgresql.conf.
- -Weź pod uwagę, że jeśli zwiększysz wartość podaną w opcji - -N na więcej niż 32 musisz także zwiększyć wartość w opcji - -B ponad jej domyślną wartość 64; wartość -B musi być - co najmniej dwa razy większa od wartości podanej w opcji - -N, a prawdopodobnie powinna być w rzeczywistości jeszcze - większa dla optymalnej wydajności. - Dla dużej liczby procesów backendu na pewno zauważysz, że trzeba - zwiększyć różne parametry jądra Unixa. Rzeczy, które pownieneś - sprawdzić to maksymalna liczba bloków pamięci dzielonej, - SHMMAX; maksymalna liczba semaforów, SEMMNS - oraz SEMMNI; - maksymalna liczba procesów, NPROC; maksymalna liczba - procesów na jednego użytkownika, MAXUPRC; i maksymalna - liczba otwartych plików, NFILE oraz - NINODE. Powód dla którego PostgreSQL ma limit na - maksymalną liczbę procesów backendu to obawa o wyczerpanie zasobów - systemu.
- -Katalog ten zawiera tymczasowe pliki utworzone przez executor. Dla - przykładu, jeśli jakaś operacja sortowania jest wymagana do wykonania - ORDER BY, a samo sortowanie wymaga więcej miejsca niż - parametr backendu - -S ustawił do wykorzystania, wtedy tymczasowe pliki są używane - do przechowywania tych danych.
- -Pliki tymczasowe powinny być usunięte automatycznie, ale mogło się - to nie stać jeśli proces backendu w międzyczasie nie zakończył się - poprawnie podczas operacji sortowania. Jeśli w danym momencie nie - działają żadne procesy backendów mozesz spokojnie usunąć pliki - pg_tempNNN.NN.
- -- Twórcy PostgreSQL dokonują jedynie małych zmian pomiędzy małymi - upgradami wersji, np z 7.2 do 7.2.1, wtedy upgrade nie wymaga - korzystania z dump i restore. Przy większych zmianach, np. z wersji - 7.2 do 7.3, często zmianymają wpływ na format przechowywanych danych. - Zmiany te są na tyle skomplikowane, że nie utrzymujemy zgodości z - poprzednimi wersjami PostgreSQL. dump pozwala na wydostanie danych w - takiej postaci, w której łatwe jest ich zaimportowanie do nowszych - wersji bez kłopotu. -
-- W wydaniach gdzie zmiany nie dotyczą formatu danych na dysku, można - wykorzystać skryptu pg_upgrade, do upgradu bez użycia dump/restore. - Dokumentacja do danego wydania zawiera informację czy możliwe jest - użycie pg_upgrade. -
-Zobacz w manualu opis polecenia DECLARE.
- -Zobacz w manualu opis polecenia FETCH lub użyj - polecenia SELECT ... LIMIT....
- -Nawet jeśli chesz pobrać kilka pierwszych rzędów z wyniku - zapytania, całe zapytanie musi zostać wykonane. Byc może powinieneś - skorzystać z polecenia ORDER BY. - Jeśli istnieje indeks który odpowiada polom określonym przez - ORDER BY, PostgreSQL może wykorzystać jedynie kilka - pierwszych rzędów, być może będzie konieczność wykonania zapytania do - momentu aż zostaną znalezione pożądane wyniki.
-- Aby otrzymać losowy rząd, użyj:
-- SELECT col - FROM tab - ORDER BY random() - LIMIT 1; -- -
Możesz sprawdzić zawartość źródeł psql, a konkretnie plik - pgsql/src/bin/psql/describe.c. Zawiera on polecenia - SQL które generuja wyniki komend z backslashem. - Możesz także uruchomić psql z opcją - -E wtedy po wykonaniu polecenia z backslashem wyświetlane - będzie zapytanie, które w rzeczywistości jest wykonywane.
- -DROP COLUMNT zostało dodane w wersji 7.3 przy poleceniu ALTER - TABLE DROP COLUMN. We wcześńiejszych wersjach możesz zrobić tak: -
-- BEGIN; - LOCAL TABLE old_table; - SELECT ... -- wybierz wszystkie kolumny poza tą jedną której chcesz się pozbyć - INTO TABLE new_table - FROM old_table; - DROP TABLE old_table; - ALTER TABLE new_table RENAME TO old_table; --
- Aby zmienić typ danych kolumny możesz zrobić tak: -
-- BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; -- -
Oto wszystkie ograniczenia:
-- Maksymalny rozmiar dla bazdy danych? nieograniczony ( istnieją - bazy danych o wielkości 32 TB databases ) - Maksymalny rozmiar dla tabeli? 32 TB - Maksymalny rozmiar dla rzędu? 1.6 TB - Maksymalny rozmiar pola? 1 GB - Maksymalna liczba rzędów w tabeli? nieograniczona - Maksymalna liczba kolumn w tabeli? 250-1600 w zależoności od typów kolumn - Makasymalna liczba indeksów na tabeli? nieograniczona -- - Oczywiście "nieograniczony" nie jest prawdą tak do końca, istnieją - ograniczenia wynikające z dostępnego miejsca na dysku, pamięci/swapa. - Kiedy wielkości te będą bardzo duże może odbić się to na wydajności. - -
Maksymalny rozmiar tabeli, czyli 32 TB nie wymaga od systemu - operacyjnego wsparcia dla dużych plików. Duże tabele są przechowywane - jako pliki o rozmiarze 1 GB, więc ograniczenia co do wielkości plików - narzucone przez system plików nie są istotne.
- -Masymalny rozmiar tabeli i maksymalna liczba kolumn może być - zwiększona jeśli zwiększymy domyślny rozmiar bloku (block size) do - 32k.
- -Baza danych PostgreSQL może potrzebować do pięciu razy więcej - miejsca na przechowywanie danych z plików tekstowych niż ich - objętość.
- -Jako przykład możemy rozważyć plik składający się z 100,000 linii - zbudowanych z liczby całkowitej oraz opisu tekstowego w każdej. - Załóżmy, że średnio każdy łańcuch tekstu w linii zajmuje 20 - bajtów. Cały plik powinien zajmować ok. 2.8 MB. Rozmiar pliku bazy danych w - PostgreSQL zawierającego te dane mozna oszacować na około 6.4MB:
- -- 36 bajtów: nagłówek każdego rzędu w przybliżeniu) - 24 bajty: jedno pole int i jedno pole typu text - + 4 bajty: wkaźnik na stronie do krotki - -------------------------------------------------- - 64 bajty w jednym rzędzie - - Strona danych w PostgreSQL zajmuje 8192 bajtów (8 KB), więc: - - 8192 bajtów na stronę - --------------------- = 128 rzędów na jedną strone w bazie (zaokrąglone w dół) - 64 bajtów na rząd - - 100000 rzędów danych - ----------------------- = 782 stron w bazie danych (zaokrąglone w górę) - 128 rzędów na stronę - -782 stron w bazie * 8192 bajtów na stronę = 6,406,144 bajtów (6.4 MB) -- -
Indeksy nie powodują dużego narzutu na zajmowane miejsce, - ale zawierają pewne dane, - więc w pewnych przypadkach moga być całkiem duże.
-NULLe są przechowywane jako mapy bitowe, więc używają bardzo mało - miejsca. -
- -psql ma całkiem dużą ilość poleceń z backslashem aby - wydobyć takie informacje. Wprowadź \? aby zobaczyć ich spis. Istnieją - także tablice systemowe rozpoczynające się od pg_, zawierające - interesujące Ciebie informacje. Wykonanie psql -l pokaże spis - wszystkich baz danych.
- -Obejrzyj także plik pgsql/src/tutorial/syscat.source. - Zawiera on wiele z zapytań typu SELECT, które są - potrzebne aby wydobyć informacje z tablic systemowych.
- -Żeby zdecydować czy indeks powinien byc używany, PostgreSQL musi - mieć statystyki dotyczące danej tabeli. Są one gromadzone przez - użycie polecenia VACUUM ANALYZE, lub poprostu - ANALYZE. używając statystyk, optymalizator wie ile - rzędów jest w tabeli i może lepiej określić czy indeksy powinny być - użyte. Statystyki mogą być także pomocne w określeniu najlepszej - kolejności wykonania złączenia (join) i jego sposobu. Gromadzenie - statystyk powinno się odbywać w określonych interwałach czasu - ponieważ dane w tabelach zmieniają się.
- -Indeksy nie są zazwyczaj używane przez ORDER BY lub - przy wykonywaniu złączeń (join). Sekwencyjne przeszukiwanie po którym - następuje sortowanie jest zazwyczaj szybsze nię wyszukiwanie za - pomocą indeksu na dużej tabeli.
-Jakkolwiek LIMIT w połączeniu z ORDER BY - często będzie wykorzystywał indeksy ponieważ jedynie mała część z - tabeli jest zwracana. W rzeczywistości, chociaż MAX() i MIN() nie - używają indeksów, możliwe jest aby zwrócić te wartości używając - indeksów poprzez użycie ORDER BY i LIMIT. -
-- SELECT col - FROM tab - ORDER BY col [ DESC ] - LIMIT 1; --
- Jeśli uważasz, że optimizer myli się wybierając sequential scan, użyj - SET enable_seqscan TO 'off' i uruchom testy aby sprawdzić czy wtym - wypadku zapytanie będzie szybciej wykonywane.
- -Kiedy używa się operatorów dopasujących takich jak - LIKE lub ~, indeksy będą używane jedynie w - pewnych wypadkach:
-Zobacz manual dla polecenia EXPLAIN.
- -Indeks R-tree jest używany do indeksowania danych przestrzennych. - Indeks hasuujący nie nadaje się do wyszukiwania odległości. - Natomiast indeks typu B-tree może wyszukiwać odleglości jedynie w - jednowymiarowych przestrzeniach. R-tree indeks radzi sobie z - przestrzeniami wielo-wymiarowymi. Dla przykładu, jeśli zostanie - założony indeks typu R-tree na polu typu point, system może - bardziej wydajnie odpowiadać na zapytania typu - "select all points within a bounding rectangle."
- -Źródłowym dokumentem opisującym oryginalnie projektowanie R-tree - indeksów jest:
- -Guttman, A. "R-trees: A Dynamic Index Structure for Spatial - Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt - of Data, 45-57.
- -Ten dokument możesz znaleźć także w pracy Stonebraker'a "Readings in - Database Systems".
- -Wbudowane indeksy R-trees radzą sobie w wielobokami i boxes. - Teoretycznie, indeksy R-tree mogą być rozszerzone o możliwości - indeksowania w więcej wymiarowych przestrzeniach. W praktyce, - rozbudowa indeksów R-tree wymaga trochę pracy, a w tej chwili nie - dysponujemy jakąkolwiek dokumentacją jak to zrobić.
- -Moduł GEQO ma za zadanie przyspieszenie - optymalizacji zapytań łącząc wiele tabel za pomocą algorytmów - genetycznych (Genetic Algorithm (GA)). Pozwala na używanie dużych - zapytań łączących tabele (join queries) bez wykorzystywania - zasobożernego wyszukiwania.
- -Operator ~ moze być wykorzystywany do wyszukiwania za - pomocą wyrażeń regularnych, a - ~* do wyszukiwania case-insensitive z wyrażeniami - regularnymi. - Wariant case-insensitive dla LIKE został nazwany - ILIKE.
- -Porównania case-insensitive są zazwyczaj wykonywane w następujący - sposób:
-- SELECT * - FROM tab - WHERE lower(col) = 'abc' - -- W tym wypadku standardowe indeksy nie będą używane. Możesz utworzyć - indeks funkcyjny, poprzez: -
- CREATE INDEX tabindex on tab (lower(col)); - -- -
Możesz to sprawdzić, testując wartość kolumny warunkiem - IS NULL albo IS NOT NULL.
- --Type Nazwa wewnętrzna Uwagi --------------------------------------------------- -VARCHAR(n) varchar rozmiar określa maksymalną długość, nie ma tutaj wypełniania -CHAR(n) bpchar wypełniane pustymi znakami do podanej długości -TEXT text bez limitu na długość łańcucha -BYTEA bytea zmiennej długości tablica bajtów (null-byte safe) -"char" char 1 znak -- -
Jeśli będziesz przeglądać katalogi systemowe lub komunikaty o - błędach często spotkasz się z podanymi powyżej nazwami - wewnętrznymi.
- -Pierwsze cztery typy powyżej to tzw typy "varlena" (np. pierwsze - cztery bajty na dysku to długość, po których jest data). Dlatego - faktyczna długośc takiego łańcucha jest trochę większa niż - zadeklarowany rozmiar. Te typy także podlegają kompresji lub mogą być - przechowywane out-of-line jako TOAST, więc faktyczne - zużycie miejsca na dysku może być mniejsze niż oczekiwane.
- -VARCHAR(n) jest - najodpowiedniejszy do przechowywania łańcuchów o różnej długości - ale określa on maksymalną jego długość. - - TEXT jest najlepszy dla łańcuchów o dowolnej długości, - nie przekraczającej 1GB.
- -- CHAR(n) jast najlepszym typem do przechowywania - łańcuchów o tej samej długości. CHAR(n) wypełnia dane do żadanej - długości, podczas gdy VARCHAR(n) przechowuje jedynie dane - dostarczone. - - BYTEA służy do przechowywania danych binarnych, - w szczególności dla danych zawierających NULL bajty. - Wszystkie typy opisane tutaj maja podobne charakterystyki jeśli - chodzi o wydajność.
- -PostgreSQL ma zaimplementowany typ SERIAL. - Automatycznie tworzy sekwencję i indeks na tej kolumnie. Dla - przykladu:
-- CREATE TABLE person ( - id SERIAL, - name TEXT - ); -- zostanie automatycznie prztłumaczone na: -
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
- CREATE UNIQUE INDEX person_id_key ON person ( id );
-
- Więcej informacji o sekwencjach znajdziesz w manualu o
- create_sequence. Możesz także użyć pola OID jako
- unikalnej wartości dla każdego rzędu danych. Jeśli będziesz
- potrzebował z backupować dane robiąc dump bazy i odtworzyć ją, musisz
- użyc pg_dump z opcją -o lub polecenia COPY
- WITH OIDS aby zachować OIDy.
-
- Jednym z podejść jest pobranie kolejnej wartości typu - SERIAL z sekwencji za pomocą funkcji nextval() - zanim zostanie wstawiona, a później należy jej użyć. Używając - przykładu z tabeli z punktu 4.15.1, może to - wyglądać w Perlu na przykład w ten sposób:
- -
- new_id = output of "SELECT nextval('person_id_seq')"
- INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal');
-
- Będziesz miał wtedy tą wartość przechowaną w zmiennej
- new_id do użytku w innych zapytaniach (np. jako klucz
- obcy do tabeli person). Warto zwrócić uwagę, że nazwa
- automatycznie utworzonej sekwencji
- SEQUENCE będzie następująca:
- <tabela>_<kolumnatypuserial>_seq,
- gdzie
- tabela i kolumnatypuserial są nazwami Twojej tabeli i
- Twojej kolumny typu SERIAL.
-
- Inne rozwiązanie to użycie funkcji currval() na pola typu - SERIAL po dodaniu nowej wartości do rzędu zawierającego - kolumnę typu SERIAL z wstawioną domyślnie wartością, - np.
-
- INSERT INTO person (name) VALUES ('Blaise Pascal');
- new_id = output of "SELECT currval('person_id_seq')";
-
- Ostatecznie możesz użyć OID
- zwracanej po wykonaniu INSERT, chociaż to jest najmniej
- przenośne rozwiązanie.
- W Perlu, wykorzystując bibliotekę DBI z modułem Edmunda Mergla
- DBD::Pg, oid jest dostępny poprzez $sth->{pg_oid_status} po
- wykonaniu $sth->execute().
-
- Nie. currval() zwraca bieżącą wartość przypisaną przez Twój - backend, a nie przez wszystkich użytkowników.
- -Aby poprawić zbieżność (concurrency), wartości sekwencji są - podawane działającym transakcjom kiedy tego potrzebują i nie są - blokowane dopóki transakcja się nie zakończy. To spowoduje przerwy w - numerowaniu z przerwanych transakcji.
- -OID są PostgreSQL'owym rozwiązaniem problemu - unikalnych numerów rzędów. Każdy rząd tworzony przez PostgreSQL - otrzymuje unikalny OID. Wszystkie OIDy - generowane podczas procesu uruchamianego przez skrypt - initdb mają mniejszą wartość niż 16384 (na podstawie pliku - backend/access/transam.h). Wszystkie - OIDy tworzone przez użytkownika sa równe lub większe - podanej wcześniej wartości. Domyślnie - wszystkie OIDy są unikalne nie tylko w pojedyńczej - tabeli czy bazie danych ale w całej instalacji PostgreSQL.
- -PostgreSQL używa OIDów w swoim wewnętrznym systemie - tabel, aby można było je łączyć. - Te OIDy mogą byc używane aby identyfikowac rzędy w - tabelach i wykorzystywać je w złączeniach tych tabel. Zaleca się abyś - używał typu OID aby przechowywać wartości - OID. Możesz utworzyć indeks na polu - OID aby dostęp do niego był szybszy.
- -OID są przypisane do wszystkich rzędów z jednego - głównego miejsca i używane sa przez wszystkie bazy danych. Jeśli - chciałbyś zmienić OID na coś innego, lub jeśli - chciałbyś zrobić kopię tabeli, z orginalnymi OIDami - nie ma żadnego przeciwwskazania abyś to zrobił:
- -- CREATE TABLE new_table(old_oid oid, mycol int); - SELECT old_oid, mycol INTO new FROM old; - COPY new TO '/tmp/pgtable'; - DELETE FROM new; - COPY new WITH OIDS FROM '/tmp/pgtable'; - -- -
OIDy są przechowywane jako cztero-bajtowe liczby - całkowite i skończą się po osiągnięciu czterech miliardów. Nikt jak - dotąd nie zgłosił aby coś takiego się stalo, ale mamy zamiar pozbyć - się tego ograniczenia zanim ktoś to zgłosi.
- -TID są używane aby zidentyfikować konkretne rzędy z - blokami i wartością ofsetów. TIDy zmieniają się wraz - ze zmianami rzędów. Sa używane przez indeksy, aby wskazywać do - fizycznych rzędów.
- -W części kodu źródłowego i starszej dokumentacji używamy terminów, - które mają bardziej ogólne znaczenie. Oto niektóre z nich:
- -Listę terminów związanych z bazami danych możesz znaleźć pod tym - adresem:http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary/glossary.html.
- -- Prawdopodobnie wyczerpała Ci się pamięć wirtualna (virtual memory) - w systemie lub Twój kernel ma zbyt nisko - ustawione limity dla pewnych zasobów. Spróbuj wykonać następujące - polecenia zanim uruchomisz postmaster'a:
-- ulimit -d 262144 - limit datasize 256m -- W zależności od shell'a jakiego używasz jedno z tych poleceń może nie - zadziałać, ale to ustawienie pozwoli ustawić segment danych dla - procesu znacznie większy i być może pozwoli wykonać zapytanie. - To polecenie zadziała dla bieżącego procesu oraz wszytkich podprocesów - utworzonych po wykonaniu polecenia. Jeśli ten problem występuje z - klientem SQL, ponieważ backend zwraca zbyt dużo danych, - spróbuj wykonać to polecenie przed uruchomieniem klienta. - -
W psql, wpisz select version();
Musisz użyć BEGIN WORK i COMMIT
- przed i po użyciu uchwytu do dużego obiektu, tzn. musisz nimi otoczyć
- funkcje lo_open ... lo_close.
Obecnie PostgreSQL używjąc "rule" zamyka uchwyt do dużego obiektu - przy każdym wywołaniu "commit". Więc pierwsze próba zrobienia - czegokolwiek z uchwytem spowoduje wypisanie: invalid large obj - descriptor. Kod, który do tej pory działał (przynajmniej - większość razy) będzie teraz generował informację o błędzie jeśli nie - będziesz korzystał z transakcji.
- -Jeśli używasz interfejsu klienta jak ODBC być może
- będziesz musiał ustawić auto-commit off.
Użyj CURRENT_TIMESTAMP:
-
-CREATE TABLE test (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP );
-
-
-
- IN sa takie wolne?W wersjach wcześniejszych niż 7.4 łączymy podzapytania w outer queries
- poprzez sekwencyjne przeszukiwanie wyników podzapytania dla każdego rzędu
- z outer query. Jeśli podzapytanie zwraca jedynie kilka rzędów a
- zewnętrzne zapytanie zwraca ich wiele, IN jest najszybsze.
- Aby przyspieszyć inne zapytania można zastąpić IN przez
- EXISTS:
-SELECT *
- FROM tab
- WHERE col IN (SELECT subcol FROM subtab)
-
-
- na:
-
-SELECT *
- FROM tab
- WHERE EXISTS (SELECT subcol FROM subtab WHERE subcol = col)
-
-
- - Aby to rozwiązanie było szybkie, subcol powinna być kolumną - indeksowaną. -
-- W wersji 7.4 i późniejszych, IN w rzeczywistości używa tej samej - wyrafinowanej techniki łączenia jak normalne zapytania i jest - preferowane nad używaniem EXISTS. -
-PostgreSQL ma zaimplementowane outer join - wykorzystując standardową składnię SQL. Poniżej dwa przykłady:
- -- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -- or -
- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- -
Te dwa identyczne zapytania łączą kolumnę t1.col z kolumną t2.col, - ale także zwrócą niepołączone rzędy w t1 (te, które nie pasują w t2). - RIGHT join dodałby niepołączone rzędy z tabeli t2. - FULL join zwróciłby rzędy plus dodatkowo wszystkie - rzędy z tabel t1 i t2. Słowo OUTER jest opcjonalne i - jest dodawane domyślnie przy - LEFT, RIGHT, i FULL - join'ach. Zwykłe join'y są nazywane INNER joins.
- -W poprzednich wersjach "outer joins" mogą być zasymulowane poprzez
- użycie slowa kluczowego
- UNION i NOT IN. Dla przykładu, łącząc
- tabele tab1 i tab2, następujące zapytanie wykonuje
- outer join:
-
-
- SELECT tab1.col1, tab2.col2 - FROM tab1, tab2 - WHERE tab1.col1 = tab2.col1 - UNION ALL - SELECT tab1.col1, NULL - FROM tab1 - WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2) - ORDER BY col1 -- -
Nie ma takiej możliwości aby w zapytaniu odpytawać inną baze danych - poza bieżącą. Ponieważ PostgreSQL ładuje specyficzne dla bazy danych - katalogi systemowe, nie jest do końca jasne jak zapytanie pomiędzy - różnymi bazami danych powinno się zachowywać.
- -contrib/dblink pozwala na wykonywanie zapytań poprzez różne - bazy danych wywołując odpowiednie funkcje. Oczywiście klient może łączyć - się z różnymi bazami danych i łączyć informację w ten sposób uzyskaną - po stronie klienta.
- -Możesz w łatwy sposób zwracać wiele rzędów lub kolumn używając - funkcji z: http://techdocs.postgresql.org/guides/SetReturningFunctions.
- -- PL/PgSQL przechowuje w cache zawartość funkcji, niepożądanym efektem tego - jest to, że gdy taka funkcja korzysta z tabel tymczasowych, które są - później kasowane i odtwarzane, a funkcja wywoływana jest ponownie,jej - wywołanie nie powiedzie się ponieważ cachowana funkcja wciąż będzie - wskazywać na stara tablicę tymczasową. Rozwiązaniem tego problemu jest - używanie EXECUTE aby korzystać z tabel tymczasowych w PL/PgSQL. To - spowoduje, że zapytanie będzie parsowane przy każdym wywołaniu - funkcji. -
- -- Jest kilka opcji aby stosować replikację typu master/slave. Ten typ - pozwala jedynie masterowi na dokonywanie zmian w bazie danych, a - slave może jedynie te zmiany odczytywać. Na stronie - http://gborg.PostgreSQL.org/genpage?replication_research - znajduje się ich lista. Replikacja typu multi-master jest w trakcie - prac, opis projektu znajduje się pod adresem: -http://gborg.PostgreSQL.org/project/pgreplication/projdisplay.php. -
- -Problem może być spowodowany przez bardzo wiele rzeczy. Spróbuj - najpierw przetestować Twoją funkcję w samodzielnie działającym programie. -
- -Wyślij Twoje propozycje na listę mailową pgsql-hackers, - wtedy prawdopodobnie Twój kod znajdzie się w katalogu contrib/.
- -- W wersjach PostgreSQL od numeru 7.3, funckje zwracające tabele są w - pęlni wspierane w C, PL/PgSQL i SQL. Sprawdź w Programmer's Guide aby - uzyskać więcej informacji. Przykład funkcji napisanej w C zwracającej - tabelę został umieszczony w contrib/tablefunc. -
- -Pliki Makefiles nie mają dorzuconych odpowiednich - zależności dla plików nagłówkowych (include files). Wykonaj najpierw - make clean, a następnie ponownie make. - Jeśli używasz GCC możesz użyć opcji - --enable-depend przy wykonywaniu configure aby - kompilator mógł określić zależności samodzielnie. -
- - - diff --git a/doc/src/FAQ/FAQ_russian.html b/doc/src/FAQ/FAQ_russian.html deleted file mode 100644 index e92ce71c062..00000000000 --- a/doc/src/FAQ/FAQ_russian.html +++ /dev/null @@ -1,1197 +0,0 @@ - - - - - - - - -Дата последнего обновления: Среда 25 июня 23:54:14 EDT 2008
- -Английский вариант сопровождает: Брюс Момьян (Bruce Momjian) (bruce@monjian.us) -
-Перевёл на русский: Виктор Вислобоков (admin@postgresql.ru.net)
-
Самую свежую английскую версию документа можно найти на - http://www.postgresql.org/files/documentation/faqs/FAQ.html.
- -Самую свежую русскую версию документа можно найти на - http://postgresql.ru.net/docs/FAQ_russian.html.
- -Ответы на вопросы специфичные для конкретных платформ можно найти на - http://www.postgresql.org/docs/faq/.
-PostgreSQL произносится Post-Gres-Q-L (Пост-Грес-Кью-Эл). - (Для особо любопытствующих как произносить "PostgreSQL", существует - аудио-файл). -
- -PostgreSQL - это объектно-реляционная система управления базами - данных (СУБД), которая имеет традиционные возможности коммерческих - СУБД с расширениями, которые есть в СУБД - нового поколения. PostgreSQL - это свободное и полностью открытое - программное обеспечение.
- -Разработку PostgreSQL выполняет команда разработчиков, разбросанная - по всему миру и связанная через Интернет. Разработка является - общественным проектом и не управляется какой-либо компанией. - Подробности смотрите в FAQ для разработчиков, - - http://www.postgresql.org/docs/faqs.FAQ_DEV.html -
- -Postgres — это широко используемое сокращение для PostgreSQL. - Первоначальным именем проекта в Беркли было Postgres и этот ник теперь - наиболее популярен в разговорах о PostgreSQL по сравнению с другими. - Если вам трудно полностью проговаривать 'PostgreSQL', можно просто - говорить 'Postgres'.
- -Если вы ищите какого-то особенного человека, центральный - комитет или управляющую компанию, то напрасно --- их нет. - У нас есть ядро комитета и разработчиков, работающих с CVS, - но эти группы служат больше для административных целей, чем - для управления. Проект напрямую функционирует с помощью - сообщества разработчиков и пользователей, к которому может - присоединится каждый. Всё что нужно -- это подписаться на - списки рассылки и участвовать в дискуссиях. (Подробности о - том как включиться в разработку PostgreSQL смотрите в - - FAQ для разработчиков.)
- -PostgreSQL распространяется по классической лицензии BSD. Эта - лицензия не содержит ограничений на то, как будет использоваться - исходный код. Нам нравится эта лицензия и у нас нет намерений её - менять. Вот эта лицензия BSD, которую мы используем:
- -Система Управления Базами Данных PostgreSQL
- -Portions copyright (c) 1996-2008, PostgreSQL Global Development - Group Portions Copyright (c) 1994-1996 Regents of the University of - California
- -Предоставляются права на использование, копирование, изменение - и распространение данного программного обеспечения и его документации - для любых целей, бесплатно и без подписания какого-либо соглашения, - при условии что для каждой копии будут предоставлены данное выше - замечание об авторских правах, текущий параграф и два следующих - параграфа.
- -КАЛИФОРНИЙСКИЙ УНИВЕРСИТЕТ НЕ НЕСЕТ НИКАКОЙ ОТВЕТСТВЕННОСТИ - ЗА ЛЮБЫЕ ПОВРЕЖДЕНИЯ, ВКЛЮЧАЯ ПОТЕРЮ ДОХОДА, НАНЕСЕННЫЕ ПРЯМЫМ - ИЛИ НЕПРЯМЫМ, СПЕЦИАЛЬНЫМ ИЛИ СЛУЧАЙНЫМ ИСПОЛЬЗОВАНИЕМ ДАННОГО - ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ЕГО ДОКУМЕНТАЦИИ, ДАЖЕ ЕСЛИ - КАЛИФОРНИЙСКИЙ УНИВЕРСИТЕТ БЫЛ ИЗВЕЩЕН О ВОЗМОЖНОСТИ ТАКИХ - ПОВРЕЖДЕНИЙ.
- -КАЛИФОРНИЙСКИЙ УНИВЕРСИТЕТ СПЕЦИАЛЬНО ОТКАЗЫВАЗЫВАЕТСЯ ПРЕДОСТАВЛЯТЬ - ЛЮБЫЕ ГАРАНТИИ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ТОЛЬКО ЭТИМИ ГАРАНТИЯМИ: - НЕЯВНЫЕ ГАРАНТИИ ПРИГОДНОСТИ ТОВАРА ИЛИ ПРИГОДНОСТИ ДЛЯ ОТДЕЛЬНОЙ ЦЕЛИ. - ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ НА ОСНОВЕ ПРИЦИПА - "КАК ЕСТЬ" И КАЛИФОРНИЙСКИЙ УНИВЕРСИТЕТ НЕ ОБЯЗАН ПРЕДОСТАВЛЯТЬ - СОПРОВОЖДЕНИЕ, ПОДДЕРЖКУ, ОБНОВЛЕНИЯ, РАСШИРЕНИЯ ИЛИ ИЗМЕНЕНИЯ.
- -Обычно, PostgreSQL может работать на любой современной платформе - совместимой с Unix. В инструкции по установке, вы найдете список - тех платформ, на которых были проведены тестовые запуски PostgreSQL - к моменту выхода данной версии.
- -PostgreSQL также работает на операционных системах Microsoft - Windows, основанных на NT, таких как Win2000 SP4, WinXP и Win2003. - Пакет инсталлятора доступен по адресу - - http://www.postgresql.org/download/windows. Версии Windows, - основанные на MS-DOS (Win95, Win98, WinMe) могут запускать - PostgreSQL с помощью Cygwin.
- -Также существует версия спортированная под Novell Netware 6 на - http://developer.novell.com/wiki/index.php/Postgresql, - и версия для OS/2 (eComStation) на - - http://hobbes.nmsu.edu/cgi-bin/h-search?sh=1&button=Search&key=postgreSQL&stype=all&sort=type&dir=%2F.
- -Через браузер, используя - http://www.postgresql.org/ftp/ и через ftp, используя - ftp://ftp.postgresql.org/pub/.
- - -Последний выпуск PostgreSQL - это версия 8.3.3
- -Мы планируем выпускать новые старшие версии каждый год, - а младшие версии каждые несколько месяцев.
- - -Сообщество PostgreSQL предоставляет помощь множеству пользователей - через E-mail. Основной web-сайт для подписки на списки рассылки по - E-mail это: - http://www.postgresql.org/community/lists/. Хорошим местом для - того, чтобы начать задавать вопросы являются списки general - (общие вопросы) или bugs (ошибки).
- -Главным IRC каналом является #postgreql,
- расположенный на сервере Freenode (irc.freenode.net). Чтобы
- подключиться, вы можете использовать в Unix вызов программы
- irc -c '#postgresql' "$USER" irc.freenode.net или
- любой другой IRC клиент. На этом же сервере существуют каналы на
- испанском (#postgresql-es), французском (#postgresqlfr)
- и бразильском (#postgresql-br) языках. Также существует канал
- по PostgreSQL на сервере EFNet.
Список коммерческой поддержки компаний доступен на - - http://www.postgresql.org/support/professional_support.
- - -Посетите страничку со специальной формой отчёта об ошибке в - PostgreSQL по адресу: - - http://www.postgresql.org/support/submitbug. - Также проверьте наличие более свежей версии PostgreSQL на нашем - FTP сайте - ftp://ftp.postgresql.org/pub/.
- -На ошибки, уведомление о которых были сделаны через специальную - форму или отправленные в какой-либо список рассылки PostgreSQL, - обычно генерируется один из следующих ответов:
-PostgreSQL поддерживает расширенный подкласс SQL:2003. - Смотрите наш список TODO - на предмет известных ошибок, отсутствующих возможностей и будущих - планов.
- -На запрос какой-либо возможности обычно приходят следующие ответы:
-PostgreSQL не использует какую-либо систему отслеживания ошибок, - потому что мы обнаружили, что использование прямого обращения по - электронной почте и обновляемого списка - TODO - является более эффективным. На практике, ошибки в программном - обеспечении сохраняются очень недолго, а ошибки, которые важны - большому количеству пользователей исправляются моментально. Есть - только одно место, где можно найти все изменения, улучшения и - исправления, сделанные в выпуске PostgreSQL - это журналы сообщений - системы контроля версий - CVS. - Даже замечания к выпускам не содержат все изменения, сделанные - в программном обеспечении.
- - -PostgreSQL содержит много документации, включая большое руководство, - страницы электронного руководства man и некоторые маленькие тестовые - примеры. Смотрите в каталог /doc. Вы также можете просматривать - документацию в Интернет по адресу - http://www.postgresql.org/docs.
- -Существует две книги по PostgreSQL доступные по адресам http://www.PostgreSQL.org/docs/books/awbook.html - и http://www.commandprompt.com/ppbook/. - Есть несколько книг по PostgreSQL, которые можно купить. - Одну из наиболее популярных написал Корри Дуглас (Korry Douglas). - Список обзоров по этим книгам доступен по адресу - http://www.postgresql.org/docs/books/. - Кроме того, по адресу http://wiki.postgresql.org/wiki/Community_Generated_Articles%2C_Guides%2C_and_Documentation - вы можете найти коллекцию технических статей, посвещенных PostgreSQL.
- -Клиент командной строки psql имеет несколько команд \d для - отображения информации по типам, операторам, функциям, агрегатам и т.д. - - используйте \? для получения списка доступных команд.
- -Наш сайт содержит еще больше информации.
- - -Во-первых, возьмите одну из книг по PostgreSQL, о которых говорилось - выше. Многим из наших пользователей также нравится книга - The Practical SQL Handbook, - Bowman, Judith S., et al., Addison-Wesley. Другим нравится The - Complete Reference SQL, Groff et al., McGraw-Hill.
- -Существует также множество прекрасных учебников доступных в online: -
Смотрите - FAQ для разработчиков.
- - -- Существует несколько методов сравнения программного обеспечения: - возможности, производительность, надежность, поддержка и цена.
- -PostgreSQL разрабатывается по архитектуре клиент/сервер, которая - требует отдельных процессов для каждого клиента и сервера, а также - несколько вспомогательных процессов. Многие встраиваемые архитектуры - могут соответствовать таким требованиям. Однако, если ваша встраиваемая - архитектура требует сервер баз данных для запуска внутри прикладного - процесса, вы не можете использовать Postgres и вам лучше бы выбрать - для базы данных какое-либо другое облегченное решение.
- -Изменения в сохранении дневного времени в США включены в PostgreSQL версии - 8.0.[4+] и во все следующие выпуски, например в 8.1. Изменения по Канаде - и Западной Австралии включены в 8.0.[10+], 8.1.[6+] и все следующие - выпуски. Выпуски PostgreSQL до 8.0 используют информацию о сохранении - дневного времени из базы данных временных зон в операционной системе.
-Страница Majordomo - на сайте PostgreSQL позволяет подписаться или отписаться от любого из списков - рассылки PostgreSQL. (Вам может понадобится ваш пароль для Majordomo, который - отправляется на ваш E-mail, чтобы войти в управление вашими подписками.)
- -Все списки рассылки PostgreSQL настариваются так, чтобы групповой ответ уходил - на адрес списка и на адрес автора сообщения. Так сделано, чтобы пользователи - получали ответы на E-mail как можно быстрее. Если вы не хотите получать дублирующие - E-mail сообщения из списка, в случаях когда вы уже получили эти сообщения напрямую, - установите флажок eliminatecc на странице Change Settings в - Majordomo. Вы также можете избежать получения копий своих сообщений для самого себя, - если снимите флажок selfcopy.
- -Установка PostgreSQL включает только C и встроенный - (embedded) C интерфейсы. Все другие интерфейсы - являются независимыми проектами и загружаются отдельно; самостоятельность - проектов позволяет им организовать собственное расписание выпусков - новых версий и иметь собственную команду разработчиков.
- -Некоторые языки программирования, такие как PHP - включают в себя интерфейс к PostgreSQL. Интерфейсы для таких языков - как Perl, TCL, Python и многих других, доступны на - http://pgfoundry.org.
- -Прекрасное введение во взаимодействие баз данных и Web можно найти на: - http://www.webreview.com
- -Для интеграции с Web, PHP - http://www.php.net является неплохим интерфейсом.
- -В сложных случаях, многие пользуются Perl и DBD::Pg с CGI.pm - или mod_perl.
- -Для PostgreSQL существует большое количество инструментов с - графическим интерфейсом как коммерческих, так и открытых. Подробности - можно найти в - Документации сообщества для GUI иструментов PostgreSQL
- -Задайте опцию --prefix когда запускаете configure.
- -По умолчанию, PostgreSQL разрешает только соединения на локальной - машине через сокеты домена Unix или TCP/IP соединения. Для того, чтобы - другие машины смогли подключиться к базе вы должны изменить - listen_addresses в postgresql.conf, разрешить - host-авторизация в файле $PGDATA/pg_hba.conf и перестартовать - сервер СУБД.
- -Существует три главных области, которые потенциально могут - увеличить производительность:
- -Есть множество установок в настройках сервера, начинающихся
- на log_* на http://www.postgresql.org/docs/current/interactive/runtime-config-logging.html,
- позволяющих протоколировать запросы и статистику работы процесса,
- которая очень полезна для отладки и измерения производительности.
Вы достигли установленного по умолчанию ограничения в 100 сессий - подключения к базе данных. Вам необходимо увеличить лимит на количество - конкурентных backend процессов для вашего сервера БД, - изменив значение max_connections в файле postgresql.conf - и перестартовать сервер БД.
- - -См. информацию об обновлении в http://www.postgresql.org/support/versioning - и специальные инструкции в - http://www.postgresql.org/docs/current/static/install-upgrading.html.
- - -Поскольку "железо" персональных компьютеров является наиболее - совместимым, люди склонны верить, что такое "железо" имеет одинаковое - качество. Это не так. Память ECC, SCSI и качественные материнские платы - являются более надёжными и имеют более лучшую производительность, чем - менее дорогое "железо". PostgreSQL будет работать на любом "железе", - но если для вас важны надёжность и производительность, то с вашей стороны - будет мудро поставить соответствующее "железо". Обсудить разное "железо" - можно в наших списках рассылки.
- -Для получения только нескольких строк, если вы знаете их количество - на момент выполнения SELECT используйте LIMIT.
- Если есть какой-либо индекс, который совпадает с ORDER BY, - то возможно, что весь запрос выполнен и не будет. Если вы не знаете - количества необходимых строк на момент выполнения SELECT, - используйте курсор и FETCH. - -To SELECT a random row, use:
-SELECT col - FROM tab - ORDER BY random() - LIMIT 1; -- - -
Чтобы просматривать таблицы в psql, используйте команду \dt. - Полный список команд в psql вы можете получить, используя \?. - Кроме того, вы можете посмотреть исходный код psql в файле - pgsql/src/bin/psql/describe.c. Он содержит команды - SQL которые генерируются при вводе в psql команд, - начинающихся с обратной косой черты. Вы также можете запустить - psql с опцией -E так, чтобы эта программа выдавала - запросы, которые она использует для выполнения заданных вами - команд. PostgreSQL также предоставляет SQL - совместимый с INFORMATION SCHEMA интерфейс, с помощью которого, вы - можете сформировать запрос на получение информации о базе данных.
- -Также существуют системные таблицы, начинающиеся с pg_.
- -Используйте psql -l для получения списка всех баз данных.
- -Также посмотрите файл pgsql/src/tutorial/syscat.source. - Он показывает многие из операторов SELECT необходимых - для получения информации из системных таблиц базы данных.
- - -В 8.0 и более поздних версиях, изменение типа колонки выполняется - очень легко через ALTER TABLE ALTER COLUMN TYPE.
- -В более ранних версиях сделайте так:
-- BEGIN; - ALTER TABLE tab ADD COLUMN new_col new_data_type; - UPDATE tab SET new_col = CAST(old_col AS new_data_type); - ALTER TABLE tab DROP COLUMN old_col; - COMMIT; -- -
Существуют следующие ограничения:
----
-- -Максимальный размер базы? -неограничен (существуют базы на 32 TB) -- -Максимальный размер таблицы? -32 TB -- -Максимальный размер строки? -400 Gb -- -Максимальный размер поля? -1 GB -- -Максимальное количество строк в таблице? -неограничено -- -Максимальное количество колонок в таблице? -250-1600 в зависимости от типа -- -Максимальное количество индексов в таблице? -неограничено -
Разумеется, понятие "неограничено" на самом деле ограничивается - доступным дисковым пространиством и размерами памяти/своппинга. - Когда значения перечисленные выше неоправдано большие, может - пострадать производительность.
- -Максимальный размер таблицы в 32 TB не требует чтобы операционная - система поддерживала файлы больших размеров. Большие таблицы хранятся - как множество файлов размером в 1 GB, так что ограничения, которые - накладывает файловая система не важны.
- -Максимальный размер таблицы и максимальное количество колонок - могут быть увеличены в четыре раза, если размер блока по умолчанию будет - увеличен до 32k.
- -Существует ограничение, по которому индексы не могут создаваться для - колонок длиннее чем 2,000 символов. К счастью такие индексы вряд ли - действительно кому-то нужны. Уникальность гарантируется наилучим образом, - с помощью функционального индекса из хэша MD5 длинной колонки, а - полнотекстовое индексирование позволяет искать слова внутри колонки.
- -СУБД PostgreSQL может потребоваться дискового пространства до 5 раз - больше для сохранения данных из простого текстового файла.
- -В качестве примера, рассмотрим файл в 100,000 строк в каждой, из - которых целое число и текстовое описание. При этом длина текста, - в среднем, составляет 20 байт. Размер простого файла составит 2.8 MB. - Размер базы PostgreSQL, содержащей эти же данные составит приблизительно - 5.2 MB из которых:
-- 24 байт: на каждый заголовок строки в таблице (приблизительно) - + 24 байта: одно поле с целочисленным типом и одно текстовое поле - + 4 байта: указатель на странице для всей табличной строки - ---------------------------------------- - 56 байт на строку в таблице - - Размер страницы данных в PostgreSQL составляет 8192 байт (8 KB), так что: - - 8192 байт на страницу - --------------------- = 158 строк в таблице на страницу БД (округлённо) - 52 байт на строку в таблице - - 100000 строк данных - ----------------------- = 633 страниц в БД (округлённо) - 158 строк в таблице на страницу - - 633 страниц БД * 8192 байт на страницу = 5,185,536 байт (5.2 MB) -- -
Индексы не требуют так много, но поскольку они создаются для - большого количества данных, они также могут быть велики.
- -Значения NULL хранятся как битовые карты и поэтому они - занимают очень мало места. -
- -Индексы не используются для каждого запроса. Они - используются только если таблица больше минимального размера и запрос - выбирает только маленький процент строк в таблице. Так устроено, - потому что доступ к диску с применением рандомизации при сканировании - индексов может быть медленнее, чем простое чтение таблицы или ее - последовательное сканирование.
- -Чтобы определить необходимость использования индекса для какой-либо - таблицы, PostgreSQL должен иметь статистику по этой таблице. Эта - статистика собирается при использовании VACUUM ANALYZE - или просто ANALYZE. Используя статистику, оптимизатор - узнает о том как много строк в таблице и если он должен использовать - индексы, то он может принимать лучшие решения. Статистика также - влияет на определение оптимального порядка связывания и метода связывания. - При изменении содержимого таблицы должен периодически выполнятся - сбор статистики.
- -Обычно индексы не используются для ORDER BY или для - выполнения связываний. Последовательный перебор следующий за явной - сортировкой обычно быстрее, чем поиск по индексам в большой таблице. - Однако, ORDER BY часто комбинируется с LIMIT - и в этом случае индекс будет использоваться, поскольку при выполнении - будет возвращаться небольшая часть таблицы.
- -Если вам кажется, что оптимизатор некорректно выбирает последовательный
- перебор, используйте SET enable_seqscan TO 'off' и
- запустите запрос снова, чтобы увидеть, действительно ли сканирование
- индексов быстрее.
-
Когда используются операции с шаблонами, например LIKE - или ~, индексы могут быть использованы в следующих случаях:
-text_pattern_ops который работает только для
- LIKE индексирования. Для поиска слов также можно
- использовать полнотекстовый индекс.Смотрите страницу руководства посвященную EXPLAIN.
- - -Оператор ~ производит поиск регулярного выражения, а оператор - ~* производит независимый от регистра букв поиск регулярного - выражения. Независимый от регистра вариант LIKE называется - ILIKE.
- -Независимое от регистра сравнение обычно выражается так:
-- SELECT * - FROM tab - WHERE lower(col) = 'abc'; -- - Эта конструкция не будет использовать стандартный индекс. Однако, если - вы создадите индекс выражения, он будет использован: -
- CREATE INDEX tabindex ON tab (lower(col)); --
Если вышеуказанный индекс создаётся как UNIQUE, то - колонка, для которой он создаётся может хранить символы и в верхнем, - и в нижнем регистре, индес не может иметь идентичных значений, которые - отличаются только регистром. Чтобы в колонке можно было хранить символы - только в определённом регистре, используйте ограничение - CHECK или проверку через триггер.
- -Вы просто сравниваете значение с IS NULL и - IS NOT NULL, как здесь:
-- SELECT * - FROM tab - WHERE col IS NULL; -- -
Чтобы соединить с возможными значениями NULL, используйте - COALESCE() как здесь:
-- SELECT COALESCE(col1, '') || COALESCE(col2, '') - FROM tab -- -
Чтобы отсортировать данные по значению
- SELECT * - FROM tab - ORDER BY (col IS NOT NULL); -- -
-- --
-- -Тип -Внутреннее имя -Замечания -- -VARCHAR(n) -varchar -размер задает максимальную длину, нет заполнения -- -CHAR(n) -bpchar -заполняется пустотой до фиксированной длины -- -TEXT -text -нет задаваемого верхнего ограничения или длины -- -BYTEA -bytea -массив байт переменной длины (можно использовать null-байт без опаски) -- -"char" -char -один символ -
Внутреннее имя вы можете увидеть, когда смотрите системные каталоги - и в некоторых сообщениях об ошибках.
- -Первые четыре типа являются "varlena" типами (т.е., первые - четыре байта на диске являются длинной, за которой следуют данные). - Таким образом, фактически используемое пространство больше, чем - обозначенный размер. Однако, длинные значения также сжимаются, - так что занимаемое дисковое пространство может также быть и меньше, - чем ожидалось.
- - VARCHAR(n) - это лучшее решение, когда нужно хранить - строки переменной длины, не превышающие определенного размера. - TEXT - это лучшее решение для строк неограниченной длины, - с максимально допустимой длиной в 1 гигабайт. -CHAR(n) - это лучшее решение для хранения строк, которые - обычно имеют одинаковую длину. CHAR(n) заполняется - пустотой до заданной длины, в то время как VARCHAR(n) - хранит только символы, из которых состоит строка. - BYTEA используется для хранения бинарных данных, значения - которых могут включать NULL байты. Все типы описанные - здесь, имеют сходные характеристики производительности.
- -PostgreSQL поддерживает тип данных SERIAL. Он - автоматически создает последовательность. Например:
-- CREATE TABLE person ( - id SERIAL, - name TEXT - ); -- - автоматически транслируется в: -
- CREATE SEQUENCE person_id_seq;
- CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
- );
-
-
- Автоматически созданная последовательность имеет имя вида - <таблица>_<колонка_serial>_seq, где - таблица и колонка_serial - это соответственно имена - таблицы и колонки с типом SERIAL. - Смотрите подробности о последовательностях на странице руководства - посвященной create_sequence.
- -Простейший способ получить назначенное значение SERIAL - это использовать RETURNING. Используя для примера таблицу в 4.11.1, это может выглядеть так:
- -
- INSERT INTO person (name) VALUES ('Blaise Pascal') RETURNING id;
-
-
- Вы также можете вызвать nextval() и использовать это значение в
- INSERT или вызвать currval() после
- INSERT.
-
-
- Нет. currval() возвращает текущее значение, назначенное вашей - сессией, а не другими сессиями.
- -Для реализации конкуретности, значения последовательностей, при - необходимости выдаются во время запуска транзакций и не блокируются - до полного выполнения транзакций. Это может вызывать разрывы в - нумерации при отмене транзакций.
- - -Если таблица создана с WITH OIDS, то каждая строка - получает уникальный индентификатор OID. - OID - это автоматически назначаемое уникальное 4-х - байтовое целое число, которое уникально для всей установленной СУБД. - Однако, после того как его значение превысит 4 миллиарда, значения - OID начинают дублироваться. PostgreSQL использует - OID для связывания своих внутренних таблиц.
- -Для уникального значения в строках таблицы пользователя, лучшим - способом является использование SERIAL вместо - OID, потому что последовательности SERIAL - уникальны только внутри таблицы и таким образом меньше подвержены - переполнению. Для хранения значений 8-ми байтной последовательности - доступен тип SERIAL8. - -
CTID используется для идентификации специальных - физических записей с блочными и offset значениями. CTID - изменяется после того как строки в таблице были изменены или перегружены. -
TID используется индексными записями в качестве - указателя на физические записи.
- - -Предположительно у вас закончилась виртуальная память - или что ваше ядро имеет маленький лимит на определенные ресурсы. - Попытайтесь перед запуском сервера БД выполнить следующие - команды:
-- ulimit -d 262144 - limit datasize 256m -- - В зависимости от командного интерпретатора shell, только одна из данных - команд выполнится успешно, но она позволит вам установить больший - сегмент данных процесса и возможно решит проблему. Эта команда - изменяет параметры текущего процесса и всех его потомков, созданных - после её запуска. Если у вас возникла проблема с SQL - клиентом, потому что backend возвращает слишком большой объем данных, - попытайтесь выполнить эту команду перед запуском клиента. - -
Из psql, наберите SELECT version();
Используйте CURRENT_TIMESTAMP:
--CREATE TABLE test (x int, modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- -
PostgreSQL поддерживает внешнее связывание, - используя стандартный синтаксис SQL. Вот два примера:
-- SELECT * - FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); -- - или -
- SELECT * - FROM t1 LEFT OUTER JOIN t2 USING (col); -- -
Это идентичные запросы связывания t1.col и t2.col, также возвращают - любые несвязанные строки в t1 (которые не совпадают с t2). - RIGHT связывание должно добавить несвязанные строки - t2. FULL связывание должно возвратить совпавшие - строки плюс все несвязанные строки из t1 и t2. Слово OUTER - является необязательным и назначается в LEFT, - RIGHT и FULL связываниях. Обычные - связывания называются INNER связывания.
- -Не существует способа создать запрос к базам данных отличным от текущей. - Поскольку PostgreSQL загружает системные каталоги специфичные для базы - данных, непонятно даже, как должен себя вести такой межбазовый запрос.
- -contrib/dblink позволяет запросы между базами, используя - вызовы функций. Разумеется, клиент может одновременно также устанавливать - соедиенения с различными базами данных и таких образом объединять - информацию из них.
- -Вы можете легко использовать функции, возвращающие список, - - http://wiki.postgresql.org/wiki/Return_more_than_one_row_of_data_from_PL/pgSQL_functions.
- -В PostgreSQL до версии 8.3, PL/PgSQL кэширует сценарии функции и один из - негативных эффектов этого состоит в том, что если функция PL/PgSQL обращается - к временной таблице и эта таблица позднее удаляется и пересоздается, а функция - затем вызывается снова, то ее вызов приведет к ошибке, потому что скэшированное - содержимое функции содержит указатель на старую временную таблицу. Чтобы решить - эту проблему, используйте EXECUTE для доступа к временным - таблицам в PL/PgSQL. Использование этого оператора заставит запрос - перегенерироваться каждый раз.
- -В PostgreSQL 8.3 и позднее, этой проблемы нет.
- - -Хотя "репликация" -- это единый термин, есть несколько разных технологий - для выполнения репликаций с разными особенностями для каждой.
- -Репликация Master/slave позволяет иметь один главный (master) сервер - для выполнения запросов чтения/записи, в то время как подчинённые - (slave) сервера могут производить только запросы - чтения/SELECT. Наиболее популярным решением для репликации - master-slave в PostgreSQL является - - Slony-I.
- -Репликация Multi-master позволяет выполнять запросы чтения/записи - на нескольких, реплицируемых друг с другом компьюетрах. Эта особенность - также приводит к потере производительности, потому что необходима - синхронизация изменений между несколькими серверами. Наиболее - популярным решением для такой репликации в PostgreSQL является - PGcluster. - -
Наиболее часто имена нераспознаются из-за использования двойных кавычек в - имени таблицы или колонки при создании таблицы. При использовании двойных - кавычек, имя таблицы и колонки (которые называют идентификаторами) - сохраняются в - регистро-зависимом виде; это означает, что вы должны использовать - двойные кавычки, когда указываете эти имена в запросе. Некоторые - интерфейсы, такие как pgAdmin, во время создания таблицы добавляют - двойные кавычки автоматически. Таким образом, чтобы идентификаторы - распознавались вы должны следовать одному из следующих правил: -
Son güncelleme : 15 Kasım 2004 Pazartesi - 15:03:23
-Current maintainer: Bruce Momjian
-(pgman@candle.pha.pa.us)
Çevirenler : Devrim Gündüz (devrim@tdmsoft.com)
Nicolai Tufar
-(ntufar@tdmsoft.com)
Volkan YAZICI (volkany@phreaker.net)
Bu belgenin en güncel hali, http://www.PostgreSQL.org/docs/faqs/FAQ_turkish.html -ve http://www.gunduz.org/seminer/pg/FAQ_turkish.html -adreslerinde görülebilir.
-Platforma özel sorularınız, http://www.PostgreSQL.org/docs/index.html adresinde yanıtlanır.
- -/usr/local/pgsql dizininden
- başka dizinlere nasıl kurabilirim?Bad System Call
- ya da core dumped mesajı alıyorum. Neden?IpcMemoryCreate
- hatası alıyorum. Neden?IpcSemaphoreCreate
- hatası alıyorum. Neden?Sorry, too many clients"
- hatasını alıyorum. Neden?pgsql_tmpdizinin içindeki dosyalar nelerdir?dump/reload işlemi gerçekleştirmek zorundayım?SELECT edebilirim?NULL olduğunu nasıl
- ortaya çıkarabilirim?serial/otomatik artan
- (auto-incrementing) bir alan yaratabilirim?Serial girişinin değerini nasıl alabilirim?currval() ve nextval()
- diğer kullanıcılara sorun yaratmaz mı?sequence/SERIAL
- kolonumdaki sayılarda atlamalar oluyor?OID nedir? TID nedir?ERROR: Memory exhausted in AllocSetAlloc()"
- hatasını alıyorum?invalid large
- obj descriptor" hatasını veriyor?IN kullanan subquery'lerim çok yavaş?core dump ediyor?PostgreSQL, Post-Gres-Q-L. olarak okunur
-PostgreSQL, yeni-nesil VTYS araştırma prototipi olan POSTGRES - veritabanı yönetim sisteminin geliştirilmesidir. POSTGRES'in zengin veri tiplerini ve - güçlü veri modelini tutarken, SQL'in geliştirilmiş alt kümesi - olan PostQuel dilini kullanır. PostgreSQL ücretsizdir ve kaynak kodu açık dağıtılır.
-PostgreSQL, PostgreSQL geliştirme listesine üye olan bir Internet geliştirici - takımı tarafından geliştirilir. Şu andaki koordinatör, Marc G. Fournier - (scrappy@PostgreSQL.org). - (Bu takıma nasıl katılacagınızı öğrenmek için 1.6 numaralı maddeyi - okuyunuz.) Bu takım, tüm PostgreSQL gelişiminden sorumludur.
-PostgreSQL 1.01 sürümünün yazarları Andrew Yu ve Jolly Chen idi. Bunların dışında - bir kaç kisi de uyarlama, hata ayıklama ve kodun geliştirilmesi için çalısmıştı. - PostgreSQL'in türediği orijinal Postgres kodu, lisans, lisansüstü ve akademisyenler - tarafından, Professor Michael Stonebraker (University of California, Berkeley) - koordinatörlügünde yazılmıştır.
-Berkley'deki yazılımın adı Postgres idi. SQL uyumluluğu - 1995'te eklenince, adı Postgres 95 oldu. 1996 yılının sonlarında adı - PostgreSQL olarak değiştirildi.
- -PostgreSQL Data Base Management System
- -Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group - Portions Copyright (c) 1994-6 Regents of the University of California
- -Permission to use, copy, modify, and distribute this software - and its documentation for any purpose, without fee, and without a - written agreement is hereby granted, provided that the above - copyright notice and this paragraph and the following two - paragraphs appear in all copies.
-IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY - PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL - DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS - SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF - CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY - WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE - SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE - UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, - SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-Üstteki metin klasik açık-kod lisansı olan BSD lisansıdır. Kaynak kodun nasıl - kullanılabileceğine dair sınırlamaları yoktur. Bu lisansı seviyoruz. Değiştirme - niyetimiz bulunmamaktadır.
- -Genel olarak, modern bir Unix-uyumlu platform PostgreSQL'i çalıştıracaktır. - Ayrıntılı bilgi için kurulum belgelerine bakabilirsiniz.
- -PostgreSQL 8.0 sürümü ile , PostgreSQL artık Win2000, WinXP ve Win2003 gibi Microsoft - Windows NT tabanlı işletim sistemlerinde doğal olarak çalışmaya başlamıştır. Paketlenmiş bir - kurulum programı, http://pgfoundry.org/projects/pginstaller. adresinden - indirilebilir.
- -Ayrıca, http://forge.novell.com adresinde Novell Netware 6 portu bulunmaktadır.
- -PostgreSQL için ana anonim ftp sitesi ftp://ftp.PostgreSQL.org/pub - adresidir. Yansılar için, ana web sayfamıza bakabilirsiniz.
- -Ana e-posta listesi : pgsql-general@PostgreSQL.org. PostgreSQL konusundaki tartışmalara - açıktır. Üye olmak için, aşağıdaki satırları e-postanızın body kısmına - (konu kısmına değil) yazıp, pgsql-general-request@PostgreSQL.org adresine gönderin:
-subscribe-
end
Aynı zamanda, bir digest listesi bulunmaktadır. Bu listeye üye olmak için, - pgsql-general-digest-request@PostgreSQL.org adresine, body kısmında
-subscribe-
end
yazan bir e-posta atmanız yeterli olacaktır.
-Digest postalar, ana liste 30k civarında e-postaya ulaştığında - üyelere gönderilmektedir.
-Bug'lar için bir e-posta listesi bulunmaktadır. Bu listeye üye olmak için, - pgsql-bugs-request@PostgreSQL.org adresine, body kısmında
-subscribe-
end
yazan bir e-posta atmanız yeterli olacaktır.
-Aynı zamanda, geliştiriciler için tartışma listesi bulunmaktadır. Bu listeye - üye olmak için, pgsql-hackers-request@PostgreSQL.org adresine, body kısmında
-subscribe-
end
yazan bir e-posta atmanız yeterli olacaktır.
-Bunun dışındaki e-posta listelerine ve PostgreSQL hakkında bilgiye, PostgreSQL WWW - ana sayfasından ulasabilirsiniz: http://www.PostgreSQL.org
-Aynı zamanda, EFNet üzerinde, #PostgreSQL adlı bir IRC kanalı
- bulunmaktadır. Bunun için, irc -c '#PostgreSQL' "$USER" irc.phoenix.net
- Unix komutunu kullanabilirsiniz.
Ticari destek veren firmaların listesine
-http://www.postgresql.org/users-lounge/commercial-support.html
-adresinden ulaşbilirsiniz.
- -PostgreSQL'in son sürümü 7.4.6'dır.
-Her 6-8 ayda ana sürüm çıkarılması planlanmaktadır.
- -Dağıtımın içinde, kitapçıklar, kitapçık sayfaları ve bazı küçük örnekler verilmektedir.
- /doc dizinine bakınız. Ayrıca, bu el kitapçıklarını online olarak
- http://www.PostgreSQL.org/docs/ adresinden inceleyebilirsiniz.
http://www.PostgreSQL.org/docs/awbook.html - ve http://www.commandprompt.com/ppbook - adreslerinde PostgreSQL kitapları bulunmaktadır. PostgreSQL kitablarının listesine, - http://www.ca.PostgreSQL.org/books/ adresinden ulaşaiblirsiniz. - Ayrıca, PostgreSQL konusundaki teknik makalelere de - http://techdocs.PostgreSQL.org/ adresinden ulaşabilirsiniz.
-psql'in, \d ile baslayan veri tipler, operatorler, fonksiyonlar, - aggregate'ler, vb. ile ilgili güzel komutları vardır.
-Web sitemiz daha fazla belgeyi içermektedir.
- -PostgreSQL SQL-92 uyumluluğu içindedir, standartlardan fazla da özellikleri - bulunmaktadır. Bilinen hatalar, eksik özellikler ve gelecek ile ilgili planlar için - TODO listesine bakınız.
- -http:/www.PostgreSQL.org/docs/awbook.html - adresindeki kitap SQL ögretecektir. - http://www.commandprompt.com/ppbook - adresinde de bir baska PostgreSQL kitabı bulunmaktadır.
-http://www.intermedia.net/support/sql/sqltut.shtm, - http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM - http://sqlcourse.com - ve http://sqlcourse2.com - adreslerinde de güzel belgeler bulunmaktadır.
-Bir başkası da, http://members.tripod.com/er4ebus/sql/index.htm - adresinde bulunan "Teach Yourself SQL in 21 Days, Second Edition" kitabıdır.
-Bazı kullanıcılarımız da şu kitabı önermektedirler: "The Practical SQL Handbook, - Bowman, Judith S., et al.,Addison-Wesley". Bazıları ise "The Complete - Reference SQL, Groff et al., McGraw-Hill" kitabını önermektedirler.
- -Evet.
- -Öncelikle, en son kaynak kodunu indirin ve web sitemizdeki ya da dağıtımın içindeki - PostgreSQL Developer belgesini okuyun. Ardından, pgsql-hackers ve pgsql-patches - listelerine üye olun. Üçüncü olarak da, pgsql-pacthes listesine yüksek kalitede - yamalar gönderin.
-PostgreSQL CVS arşivine erişim izni olan, 10 kadar geliştirici bulunmaktadır. - Hepsi defalarca, diğer kişilerin yaptığından çok daha yüksek-kaliteli yamalar - göndermişlerdir. Ayrıca biz de bu geliştiricilerin ekledikleri yamaların yüksek - kalitede olduğuna güveniyoruz.
- -PostgreSQL BugTool sayfasına gidiniz. O sayfada bir bug bildirmek - için neleri yapmanız gerektiği anlatılmıştır.
-Ayrıca, ftp://ftp.PostgreSQL.org/pub - ftp adresimizde, yeni bir PostgreSQL sürümü ya da yaması olup olmadığıni kontrol ediniz.
- -Bir yazılımın gücünü ölçmek için çeşitli yollar vardır: Yazılımın özellikleri, - başarımı, güvenilirliği, desteği ve ücreti.
-Özellikler:
-PostgreSQL mevcut büyük ticari veritabanlarının, transaction, - subselect, trigger, view, foreign key referential integrity - ve sophisticated locking gibi (user-defined types), rules, - inheritance ve lock cakışmalarını düşürmek için multi-version - uyumluluk özellikleri bulunmaktadır.
-Performans (Başarım):
-PostgreSQL, diğer ticari ve açık kaynak kodlu veritabanlarıyla yakın başarımı sağlar.
- Bazı açılardan daha hızlıdır, diğer açılardan da yavaştır. MySQL ya da daha zayıf
- veritabanları ile karşılaştırıldığında, INSERT/UPDATE işlemlerinde,
- transaction bazlı çalıstığımız için daha yavaşız. MySQL, yukarıdaki "özellikler"
- kısmında belirtilenlerden hiç birine sahip değildir. Biz, başarımımızı her sürümde
- arttırsak da, esneklik ve gelişmiş özellikler için yapılanmış durumdayız.
- PostgreSQL'i MySQL ile karşılaştıran şu web sitesine bakabilirsiniz:
- http://openacs.org/why-not-mysql.html
Güvenilirlik:
-DBMS'lerin güvenilir olması gerketiği, yoksa değerleri olmayacağını düşünüyoruz. - Çok iyi test edilmiş, dengeli çalısan minimum sayıda hata içeren kod sunmaya çalışıyoruz. - Her bir sürüm en az 1 aylık beta testlerinden geçirilmektedir. Sürüm geçmişine bakarsanız, - üretime hazır, dengeli ve kararlı kodlar sunduğumuzu görebilirsiniz. Bu alanda, diğer - veritabanı yazılımlarına üstünlüğümüz olduğuna inanmaktayız.
-Destek:
-E-posta listemiz, oluşan herhangi bir sorunu çözebilecek büyük sayıda kullanıcı - ve geliştirici grubunu içerir. Sorununuz için, en az bir ticari veritabanı kadar - rahat çözüm bulabilirsiniz. Gelistiricilere, kullanıcı grubuna, belgelere ve - kaynak koda direk olarak erişebilme, PostgreSQL desteğini, diğer DBMS'lere - göre daha önemli kılar. Gereksinimi olanlara, ticari destek verilebilir. - (Destek için 1.6 bölümüne bakınız.)
-Fiyat:
-Ticari ve ticari olmayan tüm kullanımlarınız için PostgreSQL ücretsizdir. Kodumuzu, - yukarıda belirtilen BSD-stili lisanstaki sınırlamalar hariç, ürününüzün içine - ekleyebilirsiniz.
- -PostgreSQL, 1996 yılından beri 1. sınıf altyapıya sahiptir. Bunun için, yıllar - boyu çalışıp bu altyapıyı oluşturup yöneten Marc Fournier'e teşekkürler.
-Bir açık kaynak kodlu proje için, kaliteli altyapı çok önemlidir. Bu altyapı, - projenin kesilmesini önler ve projenin ilerlemesini hızlandırır.
-Tabii ki bu altyapı ucuz değildir. İşlerin yürümesi için çeşitli yılık ve anlık - harcamalarımız olmaktadır. Eğer siz ya da şirketinizin bu çabamıza bağışta - bulunabilecek parası varsa, lütfen - http://store.pgsql.com/ - adresine gidiniz ve bağışta, hibede bulununuz.
-Web sayfasının 'PostgreSQL Inc.' den bahsetmesine rağmen, "katkıda bulunanlar" - (contributors) maddesi sadece PostgreSQL projesini desteklemek içindir ve - belirli bir şirketin para kaynağı değildir. isterseniz, bağlantı adresine bir - çek gönderebilirsiniz.
- -iki tane ODBC sürücüsü bulunmaktadır: PsqlODBC ve OpenLink ODBC.
-PsqlODBC'i http://gborg.postgresql.org/project/psqlodbc/projdisplay.php adresinden - indirebilirsiniz.
-OpenLink ODBC http://www.openlinksw.com adresinden alınabilir.Bu sürücü, - kendi standart ODBC istemci yazılımı ile çalıstığından, destekledikleri - her platformda (Win, Mac, Unix, VMS) PostgreSQL ODBC bulunmalidir.
-Ücretsiz sürümü olmakla beraber, ticari kalitede destek almak isteyenlere satmak isteyeceklerdir. - Sorularınızı lütfen postgres95@openlink.co.uk adresine gönderiniz.
- -http://www.webreview.com/ adresinde, - arka planda veritabanı çalıstıran Web sayfaları için giriş seviyesinde bilgi bulunmaktadır.
-Web ile bütünleşme için, PHP () - mükemmel bir arabirim sunar.
-Karmaşık sorunlar için, çoğu kisi Perl arabirimini ve CGI.pm ya da mod_perl kullanır.
- -Çeşitli grafik arabirimlerimiz bulunmaktadır. Bunların arasında, - PgAccess (http://www.pgaccess.org/), - PgAdmin II (http://www.pgadmin.org/, sadece Win32 için), - RHDB Admin (http://sources.redhat.com/rhdb/) - ve Rekall (http://www.thekompany.com/products/rekall/) - bulunmaktadır. Ayrıca, PostgreSQL için web tabanlı bir arabirim olan - PHPPgAdmin (http://phppgadmin.sourceforge.net/) bulunmaktadır.
-Daha ayrıntılı liste için - http://techdocs.postgresql.org/guides/GUITools - adresine bakabilirsiniz.
- -Diğerleri için, http://gborg.postgresql.org adresindeki Drivers/Interfaces bölümüne - bakabilirsiniz.
- -/usr/local/pgsql dizininden
- başka dizinlere nasıl kurabilirim?configure betiğini çalıstırırken, --prefix seçeneğini veriniz.
Bunun birçok nedeni olabilir. Ancak ilk kontrol edilmesi gereken sey, çekirdeginize - System V uzantılarının kurulu olup olmadıgını kontrol etmek olabilir. PostgreSQL - shared memory ve semaphores için çekirdek destegine gereksinim duyar.
- -ıpcMemoryCreate
- hatası alıyorum. Neden?Ya çekirdeğinizde shared memory desteğiniz düzgünce yapılandırılmamıştır, - ya da çekirdeğinizdeki mevcut shared memory miktarını büyütmeniz gerekecektir. - Gereksinim duyacağınız miktar, mimarinize ve postmaster için ayarladıgınız tampon - ile backend işlemi sayısına bağlıdır. Tüm sistemler için, tamponlar ve - işlemlerde öntanımlı sayılarla, ~ 1MB kadar yere gereksinmeniz olacaktır. - PostgreSQL - 7.3.2 Sistem Yöneticileri Rehberi'ne, shared memory ve semaphorelar - hakkındaki ayrıntılı bilgi için bakabilirsiniz.
- -ıpcSemaphoreCreate hatası alıyorum. Neden?Eğer hata, "ıpcSemaphoreCreate: semget failed (No space left on device)"
- ise, çekirdeğiniz yeterli semaphore ile yapılandırılmamış demektir. Postgres, her
- bir potansiyel backend için bir semaphore gereksinimi duyar. Geçici
- bir çözüm, postmasterı backend işlemleri için daha az miktarda sınırla
- başlatmak olabilir. -N'i varsayılan değer olan 32'den küçük bir
- değerle başlatınız. Daha kalıcı bir çözüm, çekirdeğinizin SEMMNS ve
- SEMMNI parametrelerini yükseltmek olacaktır.
Çalışmayan semaphore'lar ağır veritabanı işlemlerinde çökme yaratabilirler.
-Eğer hata mesajınız başka bir şey ise, çekirdeğinizde semaphore desteğini - yapılandırmamış olabilirsiniz. Shared memory ve semaphore'lar hakkındaki - daha ayrıntılı bilgi için - PostgreSQL - 7.3.2 Sistem Yöneticileri Rehberi'ne bakabilirsiniz.
- - -Ön tanımlı olarak, PostgreSQL sadece yerel makineden Unix domain sockets
- kullanarak bağlanılmasına izin verir. Diger makineler, postmaster'a -i
- etiketini geçirmezseniz ve $PGDATA/pg_hba.conf dosyasını düzenleyerek
- host-based authentication'a olanak vermezseniz, bağlantı yapamayacaklardır.
Index'ler sorguları hızlandırabilir. EXPLAIN komutu,
- PostgreSQL'in sorgunuzu nasıl yorumladığını ve hangi index'leri kullandığını
- görmenize izin verir.
Eğer cok fazla INSERT işlemi yapıyorsanız, bunları büyük bir
- toplu işlem dosyasıkullanıp COPY komutu ile veritabanına girmeyi
- deneyiniz. Bu, tekil INSERT'lerden daha hızlıdır. İkinci olarak,
- BEGIN WORK/COMMIT transaction bloğu içinde olmayan ifadeler kendi
- transaction'larındaymış gibi düşünülür. Çoklu ifadeleri tek bir
- transaction bloğu içinde yapabilirsiniz. Bu, transaction overhead'ini
- düşürecektir. Tek bir transaction bloğu içinde birden çok ifadeyi çalıştırmayı
- deneyebilirsiniz. Bu da aynı şekilde, transaction overhead'ini düşürür.
Çeşitli ayarlama seçenekleri mevcuttur. fsync() işlemini, postmaster'ı
- -o -F seçeneği ile başlatarak devre dışı bırakabilirsiniz. Bu işlem,
- fsync()'lerin her transactiondan sonra diski flush etmesini
- engelleyecektir.
Aynı zamanda, postmaster'i -B seçeneği ile başlatıp, backend
- işlemleri tarafından kullanılan shared memory buffers sayılarını arttırabilirsiniz.
- Eğer bu parametreyi çok yüksek tutarsanız, çekirdeğinizin shared memory
- bölgesindeki limiti aşma olasılığınız yüzünden postmaster başlayamayabilir. Her bir
- tampon (buffer) 8K'dır. Öntanımlı sayı ise 64 tampondur.
Aynı şekilde, backend'in -S seçeneğini geçici sıralamalar için
- backend süreçleri tarafından kullanılacak hafızayı arttırmak amacıyla
- kullanabilirsiniz. -S seçeneği kilobayt cinsinden değer alır ve ön
- tanımlı değeri 512'dir (512 K)
Tablolardaki veriyi bir index'e eşlemek amacıyla gruplama için
- CLUSTER komutunu kullanabilirsiniz. Ayrıntılı bilgi için
- CLUSTER komutunun yardım sayfasına bakabilirsiniz.
PostgreSQL, hata ayıklama amacıyla kullanılabilecek durum bilgisi - rapor eden çeşitli özeliklere sahiptir.
-Öncelikle, configure betiğini --enable-cassert seçeneğiyle
- çalıştırırsanız, bir çok assert() backend calışmasını gözlemler ve
- beklenmeyen bir durumda programı durdurur.
Postmaster ve postgres çeşitli hata ayıklama seçeneklerine sahiptir. Öncelikle, - postmaster'ı başlattığınızda, standart çıktıyı ve hataları bir log dosyasına - yönlendirdiğinize emin olun:
-cd /usr/local/pgsql-
./bin/postmaster >server.log 2>&1 &
Bu işlem PostgreSQL ana dizinine server.log dosyası yerleştirecektir.
- Bu dosya sunucunun yaşadığı sorunlar ya da hatalar hakkında yararlı bilgiler içerir.
- -d seçeneği, hata ayıklama seviyesini belirten bir rakam ile kullanılır.
- Yüksek hata ayıklama seviyelerinin büyük log dosyaları oluşturacağını unutmayınız.
Eğer postmaster çalışmıyorsa, postgres backend'ini komut satırından
- çalıştırabilir ve SQL ifadenizi direk olarak yazabilirsiniz. Bu sadece hata ayıklama
- amacıyla önerilir. Burada, noktalı virgülün değil de yeni bir satırın sorguyu
- sonlandırdığını unutmayınız. Eğer hata ayıklama sembolleri ile derlediyseniz,
- ne olduğunu görmek için bir hata ayıklayıcı kullanabilirsiniz. backend
- postmaster'dan başlatılmadığından, eşdeğer bir ortamda çalışmamaktadır ve
- locking/backend etkileşim sorunları artabilir.
Eğer postmaster çalışıyorsa, bir pencerede psql'i çalıştırın ve psql tarafından
- kullanılan postgres sürecinin süreç numarasını (PID) bulun. Postgres
- süreci ile ilişkilendirmek için bir hata ayıklarıcı kullanın. Sorguları psql aracılığı
- ile çalıştırabilirsiniz. Eğer postgres başlangıcında hata ayıklamak istiyorsanız,
- PGOPTIONS="-W n" seçeneğini ayarlayabilir ve psql'i başlatabilirsiniz.
- Bu işlem, başlangıcın n saniye kadar gecikmesini sağlayacaktır; böylece
- hata ayıklayıcıyı sürece ilişkilendirdikten sonra başlangıç sürecinin devam etmesini
- sağlayabilirsiniz.
postgres programı hata ayıklama ve başarım ölçümleri için -s,
- -A ve -t seçeneklerine sahiptir.
Postmaster'ın eşzamanlı olarak başlatabileceği backend süreçleri - sınırlarını arttırmanız gerekmektedir.
-Ön tanımlı değer 32 süreçtir. Bunu, postmaster'ı uygun -N
- değeri ile ya da postgresql.conf dosyasını düzenleyerek yeniden
- başlatmakla arttırabilirsiniz.
Eğer -N değerini 32'den büyük yapacaksanız, aynı zamanda
- -B değerini de değiştirmeniz gerektiğini unutmayın. -B,
- -N'nin en az 2 katı kadar olmalıdır; daha iyi başarım için bu sayıyı daha
- da arttırmalısınız. Yüksek sayıdaki backend süreçleri için, çeşitli çekirdek
- yapılandırma parametrelerini arttırmanız gerekecektir. Yapılması gerekenler,
- SHMMAX, SEMMNS, SEMMNI, NPROC,
- MAXUPRC ve açılabilecek dosyaların maksimum sayısı olan NFILE
- ve NINODE değerlerini karıştırmaktır. Bunun nedeni, PostgreSQL'in izin
- verilen backend süreçlerinin sayısı üzerinde bir sınırı olmasıdır. Böylelikle
- sistem kaynaklarının dışına çıkılmayacaktır.
PostgreSQL'in 6.5 sürümüne kadar, en fazla backend sayısı 64 idi ve bunu
- değiştirmek için include/storage/sinvaladt.h dosyası içindeki
- MaxBAckendid sabitini değiştirdek sonra yazılımı yeniden
- derlemek gerekiyordu.
pgsql_tmp dizinin içindeki dosyalar nelerdir?Sorgu çalıstırıcı (query executer) tarafından yaratılan geçici dosyalardır.
- Örnegin, bir sıralama ORDER BY ile yapılacaksa ve sıralama
- backend'in -s parametresinin izin verdiğinden daha
- fazla alana gereksinim duyuyorsa, ekstra veriyi tutmak için geçici dosyalar yaratılır.
Geçici dosyalar, eğer sıralama sırasında backend göçmezse otomatik olarak
- silinecektir. Eğer çalışan durumda bir backend'iniz yoksa,
- pg_tempNNN.NN dosyalarını silmeniz güvenlidir.
PostgreSQL takımı ara sürümlerde sadece küçük değişiklikler yapmaktadır; - bu yüzden 7.2 sürümünden 7.2.1'e yükseltmek dump/restore işlemi - gerekmemektedir. Ancak, esas sürümlerde (örnek: 7.2'den 7.3'e) çoğunlukla sistem - tablolarının ve veri dosyalarının iç yapısı değiştirilir. Bu değişiklikler çoğunlukla - karmaşıktır; dolayısıyla veri dosyalarının geriye dönük uyumluluğu işlemlerini - yapmıyoruz. Dump işlemi, veriyi genel biçimde alacağından yeniden yükleme - esnasında veri, yeni iç biçime uygun şekilde yerleştirilecektir.
-Disk biçiminin değişmediği sürümlerde, pg_upgrade betiği güncellemenin
- bir dump/restore gerektirmeden yapılmasını sağlayacaktır. pg_upgrade
- betiğinin o sürüm için bulunup bulunmadığını sürüm notları içinde bulabilirsiniz.
PC donanımı tamamen uyumlu olduğu için, insanlar tüm PC donanımlarının aynı kalitede olduğunu - düşünürler. Oysa böyle değildir. ECC RAM, SCSI ve kaliteli anakartlar daha ucuz donanımlara göre daha - çok güvenilirlerdir ve başarımları daha yüksektir. PostgreSQL hemen hemen tüm donanımda - çalışabilmektedir, ancak güvenilirlik ve başarım önemli ise donanım seçeneklerini çok iyi araştırmak - gereklidir. E-posta listelerimi donanımlarla ilgili sorular ve de ticaret için kullanılabilir.
- -DECLARE yardım sayfasına bakınız.
SELECT edebilirim?FETCH yardım sayfasına bakınız, ya da SELECT ...
- LIMIT ... kullanınız.
İlk birkaç satırı almak isteseniz bile, tüm sorgu değerlendirilmek durumunda kalınabilir. ORDER - BY içeren bir sorgu düşünün. Eğer ORDER BY işe eşleşen bir index varsa, PostgreSQL istenen ilk birkaç - satırı işleyebilir, ya da tüm sorgu istenen satırlar üretilene kadar işlenebilir.
- -pgsql/src/bin/psql/describe.c içindeki psql kaynak kodunu
- okuyabilirsiniz. Bu kod, psql'in \ ile başlayan komutlarının
- çıktısını olusturan SQL komutlarını içerir. Aynı zamanda, psql'i -E
- seçeneği ile başlatıp, verdiğiniz komutları çalıştırmak için yaptığı
- sorguların çıktılarını görebilirsiniz.
Bu özellik (ALTER TABLE DROP COLUMN) 7.3 sürümü ile gelmiştir.
- Eski sürümlerde aşağıdakileri uygulamalısınız:
-BEGIN; -LOCK TABLE old_table; -SELECT ... -- select all columns but the one you want to remove -INTO TABLE new_table -FROM old_table; -DROP TABLE old_table; -ALTER TABLE new_table RENAME TO old_table; -COMMIT; -- -
Sınırlar:
-Veritabanı için en fazla büyüklük nedir?
Sınırsız (32 TB'lık veritabanı bulunmaktadır)
- Bir tablo için en fazla büyüklük nedir?
32 TB
- Bir satır için en fazla büyüklük nedir?
1.6 TB
- Bir alan için en fazla büyüklük nedir?
1 GB
- Tabloda en fazla satır sayısı kaçtır?
Sınırsız
- Bir tabloda olabilecek en fazla kolon sayısı kaçtır?
Kolon tiplerine bağlı olarak 250-1600
- Bir tabloda olabilecek en fazla index sayısı kaçtır?
Sınırsız
Tabii ki bunlar aslında sınırsız degildir. Burada belirtilen sınırlar, fiziksel - sınırların haricindeki sınırlardır. Boş disk alanı, hafıza/takas alanı na bağlı - sınırlamalar vardır. Başarım, sınır değerlere yaklaştıkça, ya da değerler çok büyük - olduğunda düşebilir.
-Bir tablo için büyüklük sınırı olan 32 TB, işletim sisteminin büyük dosya desteği olup - olmamasından bağımsızdır. Büyük tablolar, 1 GB'lik dosyalarda saklandığı için, dosya - sistemi sınırlarınin bir önemi yoktur.
-Tablo ve kolon sayısı büyüklükleri, ön tanımlı blok büyüklüğü 32k ya çıkarılarak - arttırılabilir.
- -Bir PostgreSQL veritabanı, veriyi "flat" metin dosyasında saklamak için - gereken alanın 5 kat fazla disk alanına gereksinim duyabilir.
-Her satırında bir tamsayı ve metin (text) içeren, 100.000 satırlık bir - dosya düşünün. Her satırın ortalama 20 byte olduğunu farzedelim. Metin dosyası - 2.8 MB olacaktır. Bu veriyi tutan PostgreSQL veritabanı - yaklaşık 6.4 MB yer kaplayacaktır.
-- 36 byte: Her bir satır başlığı (yaklaşık) -+ 24 byte: Bir tamsayı (int) alanı ve bir metin (text) alanı -+ 4 byte: Sayfada tuple a pointer ----------------------------------------- - 64 byte -> kayıt başına-
PostgreSQL'de veri sayfası (data page) büyüklüğü 8192 byte (8k)dır, dolayısıyla:
--8192 byte -> page başına -------------------------- = Her bir veritabanı page'ı başına 128 satır (yaklaşık) - Satır başına 64 byte - -100000 veri satırı --------------------- = 782 veritabanı sayfası - 128 satır-
782 veritabanı sayfası * sayfa başına 8192 byte =
- 6,406,144 bytes (6.4 MB)
Index'ler çok fazla yere gereksinim duymazlar, ama index'lenmiş - veriyi tutacaklarından büyük olabilirler.
-NULL değerler bitmapler içinde tutulur; dolayısıyla çok az yer kaplarlar.
psql, bu tür bilgileri göstermek için, \ ile başlayan bir çok
- komut sunmaktadır. \? komutu ile bu komutları görebilirsiniz. Ayrıca,
- bunları açıklayan ve pg_ ile başlayan çok sayıda sistem tablosu
- bulunmaktadır. Aynı zamanda, psql -l ile tüm veritabanlarını
- listeyelebirsiniz.
Ayrıca, pgsql/src/tutorial/syscat.source kodunu inceleyebilirsiniz.
- Bu dosya, veritabanı sistem dosyalarından bilgiyi almak için gereksinim duyulan
- bir çok SELECT'leri gösterir.
Indexler her sorgu tarafından otomatik olarak kullanılmazlar. Indexler eğer bir - tablonun büyüklüğü minimum bir büyüklükten fazla ise ve sorgu tablodaki satırların sadece küçük bir - yüzdesini seçiyorsa kullanılır. Bunun nedeni, index erişiminin neden olduğu raslansal disk erişimi - nin diskin ya da tablonun sıralı okunmasından daha yavas olabilmesidir.
- -Bir index'in kullanılıp kullanılmayacağını belirlemek için, PostgreSQL tablo hakkındaki - istatistiklere gereksinmesi vardır. Bu istatistikler, VACUUM ANALYZE kullanılarak - toplanırlar. Optimizer, istatistikleri kullanarak, tabloda kaç satır olduğunu ve bilir ve indexin - kullanılıp kullanılmayacağına daha iyi karar verir. Istatistikler, aynı zamanda en uygun join - sırasını ve yöntemini belirlemekte çok önemlidir. İstatistik toplanması, tablo içerikleri - değiştikçe periyodik olarak yapılmalıdır.
- - -Indexler normalde ORDER BY sorguları ya da join işlemlerini gerçekleştirmek için - kullanılmazlar. Açık bir sıralamayı takip eden sıralı bir arama (sequential scan), büyük bir tabloda index - araması yapmaktan genelde daha hızlıdır.
- - Ancak, ORDER BY ile birleşmiş LIMIT - genellikle bir index kullanacaktır; çünkü tablonun sadece belirli bir miktarı döndürülecektir. - Aslında, MAX() ve MIN() fonksiyonlarının index kullanmamalarından dolayı, bu gibi değerleri ORDER BY ve LIMIT - kullanarak da almak olasıdır: -- SELECT col - FROM tab - ORDER BY col [ DESC ] - LIMIT 1; -- -
Eğer optimizer'ın sıralı arama yapmasının yanlış olduğuna inanıyorsanız, SET enable_seqscan TO
-'off' kullanın ve index kullanan aramaların hala daha hızlı olup olmadığını görün.
LIKE ya da ~ gibi operatörler kullanıyorsanız,
- index'ler sadece aşağıdaki koşullarda kullanılabilir:
LIKE sorguları % ile başlamamalıdır.^ işe başlamamalıdır.[a-e]ILIKE ve ~* gibi büyük/küçük harfe duyarsız
- aramalar index'lerden yararlanmazlar. Onun yerine, bölüm 4.12'de anlatılan
- fonksiyonel index'leri kullanabilirsiniz.EXPLAIN yardım sayfasına bakınız.
R-tree index, uzaysal (spatial) verileri indexlemek için kullanılır. Bir hash - index, dizi aramalarında (range search) kullanılamaz. B-tree index dizi aramalarında sadece tek - boyutlu çalışmaktadır. R-tree, çok boyutlu veriyi destekler. Örneğin, eğer bir R-tree index point - veri tipi üzerinde inşa edililebilirse, sistem "select all points within a bounding rectangle" - gibi sorgulara daha verimli yanıtlar verecektir.
-Orijinal R-tree tasarımını açıklayan belge:
-Guttman, A. "R-trees: A Dynamic Index Structure for Spatial Searching." - Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt of Data, 45-57.
-Bu belgeyi, Stonebraker'ın "Readings in Database Systems" kitabında bulabilirsiniz.
-Gömülü R-tree indexleri poligon ve boxları kullanabilir. Teorik olarak, - R-tree indexlerin özelliklerini genişletmek bir miktar çaba gerektirir ve bunun nasıl - yapılacağına dair bir belgemiz henüz bulunmamaktadır.
- -GEQO modülü, Genetic Algorithm(GA) kullanılarak tablolar - birleştirildiğinde sorgu optimizasyonunu hızlandırır.
- -~ operatörü düzenli ifade eşleşmesi ve ~* büyük/küçük
- harfe duyarsız düzenli ifade eşleşmesi yapar. Büyük/küçük harfe duyarlı olan
- LIKE'ın büyük/küçük harfe duyarsız olan biçimi ILIKE'tır
- ve PostgreSQL 7.1 sürümü ile birlikte gelmiştir.
Büyük-küçük harfe duyarsız eşitlik karşılaştırmaları aşağıdaki gibi ifade edilir:
--SELECT * -FROM tab -WHERE lower(col) = 'abc' --
Bu standart bir index yaratmayacaktır. Ancak eğer fonksiyonel bir - index yaratırsanız; o kullanılacaktır:
-CREATE INDEX tabindex on tab (lower(col));- -
NULL" olduğunu
- nasıl ortaya çıkarabilirim?Kolonu, IS NULL ve IS NOT NULL ile test edebilirsiniz.
-Veri Tipi İç Adı Not --------------------------------------------------- -VARCHAR(n) varchar boyut en büyük uzunluğu verir; sadece verilen kadar veri tutulur. -CHAR(n) bpchar belirtilen uzunluğa kadar sonuna boşluk eklenir. -TEXT text uzunlukta herhangi bir üst sınır yoktur. -BYTEA bytea variable-length byte array (null-byte safe) -"char" char bir karakter --
İç adları (internal name) sistem kataloglarını ve - bazı hata mesajlarını incelerken göreceksiniz.
-İlk dört veri tipi "varlena" tipidir (yani, diskteki ilk 4 bayt uzunluktur;
- devamı da veridir.) Dolayısıyla, kullanılan gerçek alan, belirtilen alandan biraz
- daha büyüktür. Ancak, bu veri tipleri, sıkıştırılmaya tabi tutulabilir; dolayısıyla
- disk alanı beklenilenden küçük olabilir. VARCHAR(n) büyüklüğü
- artabilen ama en büyük uzunluğu sınırlı olan verileri saklamak için en uygun yöntemdir.
- TEXT, 1 GB büyüklüğe kadar olan verileri tutmak için kullanılır.
CHAR(n), aynı uzunluktaki dizilerin saklanması için kullanımır.
- CHAR(n) belirtilen uzunluğa kadar boşluk ile doldurur; ancak
- VARCHAR(n) sadece verilen karakterleri saklar. BYTEA
- binary veri saklamak içindir; ayrıca "NULL" bayt içeren değerleri de saklar.
- Burada anlatılan üç veri tipi de benzer başarım karakteristiklere sahiptir.
PostgreSQL'de SERIAL veri tipi vardır. Bu veri tipi bir
- sequence ve kolon üzerinde bir index yaratır.
Örnek, aşağıdaki sorgu:
--CREATE TABLE person ( - id SERIAL, - name TEXT -); --
buna çevrilir:
-
-CREATE SEQUENCE person_id_seq;
-CREATE TABLE person (
- id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
- name TEXT
-);
-CREATE UNIQUE INDEX person_id_key ON person ( id );
-
- Sequenceler hakkında daha fazla bilgi için create_sequence
- yardım sayfasına bakabilirsiniz. Her satırın OID alanını tekil bir sayı
- olarak alabilirsiniz. Ancak, veritabanınızın dump'ını alıp yeniden yüklerseniz,
- OID değerlerini koruyabilmek için pg_dump'ın -o
- parametresini ya da "COPY WITH OIDS" seçeneğini kullanmanız gerekecektir.
SERIAL girişinin degerini nasıl alabilirim?Bir yaklaşım, sequence nesnesindeki SERIAL değerini, veriyi girmeden önce nextval() ile alıp, - aldığınız değeri kendinizin girmesidir. 4.15.1'deki örnek tabloyu kullanarak bir örnek verelim:
- -new_id = execute("SELECT nextval('person_id_seq')");
- execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
-
- Diğer sorgular için new_id'de yeni değerin saklanması gerekir. Otomatik olarak yaratılan SEQUENE nesnesinin adı, - <tablo adı>_<serial kolonu adı>_seq şeklinde olacaktır (< > işaretleri olmadan).
- -Alternatif olarak, atanmış SERIAL değerini, değer girildikten sonra currval() - fonksiyonu ile alabilirsiniz:
-
- execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
- new_id = execute("SELECT currval('person_id_seq')");
-
- Son olarak, ön tanımlı değeri bulmak için INSERT ifadesinden
- dönen OID değerini kullanabilirsiniz; ancak bu en az taşınabilir
- çözüm olacaktır. Perl'de, Edmund Mergl'in DBD:Pg mödülü ile birlikte
- DBI kullanarak, OID değeri $sth->execute()
- çalıştırıldıktan sonra $sth->(pg_oid_status) ile alınabilir.
currval() ve nextval()
- diğer kullanıcılara sorun yaratmaz mı?Hayır. curval(), tüm kullanıcılar değil, backend
- tarafından atanan geçerli değeri döndürür.
Uyumluluğu arttırmak için, sequence değerleri çalışan - transaction'lara gerektiği şekilde aktarılır ve transaction - bitene kadar o değer kilitlenmez. Bu, iptal edilen transaction - işlemleri nedeniyle boşluklara neden olur.
- -OIDler, tekil satır numaralarına PostgreSQL'in yanıtıdır. PostgreSQL'de yaratılan - her sayı, tekil bir OID alır. initdb işlemi sırasında yaratılan tüm OID'ler 16384'ten küçüktür - (backend/access/transam.h). Kullanıcılar tarafından yaratılan tüm OID'ler bu sayıya eşit ya da bu - sayıdan büyüktür. Varsayılan durumda, tüm bu OIDler sadece bir tablo ya da veritabanında değil, tüm - PostgreSQL kurulumunda tekildir.
- -PostgreSQL OIDleri, tablolar arasında satırları ilişkilendirmek için kendi iç tablolarında - kullanır. Bu OIDler belirli kullanıcı satırlarını belirtmek için kullanabilir ve join işlemlerinde - kullanılır. OID değerlerini saklamak için OID kolon tipini kullanmanız önerinir. Daha hızlı bir - erişim için, OID alanında bir index yaratabilirsiniz.
- -OID'ler yeni satırlara, tüm veritabanları tarafında kullanılan ortak bir alandan atanırlar. Eğer - OID'i başka bir değere eşitlemek isterseniz ya da tablonun bir kopyasını orijinal OIDler ile - çıkarmak isterseniz, bu mümkündür:
-- CREATE TABLE new_table(old_oid oid, mycol int); - SELECT old_oid, mycol INTO new FROM old; - COPY new TO '/tmp/pgtable'; - DELETE FROM new; - COPY new WITH OIDS FROM '/tmp/pgtable'; --
OIDler 4-bit tamsayı olarak saklanırlar ve 4 milyarda overflow olacaktır. Kimse - bu sayıya ulaştığına dair bir bilgi iletmedi ve bu sınırı kimse bu sınıra ulaşmadan kaldıracağız.
- -TIDler, belirli fiziksel satırlar block ve offset değerleri ile belirtmekte kullanılır. TIDler, - satırlar değiştiğinde ya da yeniden yüklendiğinde değişirler. Index girdileri tarafından fiziksel - satırları göstermek için kullanılırlar.
- -Kaynak kodun bir kısmı ve eski belgeler, daha geniş kullanım alanı olan terimleri - kullanırlar. Bunların bazıları:
-Genel veritabanı terimleri, - http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary/glossary.html - adresinde bulunabilir.
- -Sisteminizde sanal belleğinizi tüketmiş olabilirsiniz, ya da çekirdeğiniz - belli kaynaklar icin düşük bir sınıra sahip olabilir. postmaster'ı - başlatmadan önce aşağıdakileri deneyebilirsiniz:
--ulimit -d 262144 -limit datasize 256m --
Kabuğunuza bağlı olarak, bunlardan sadece biri olumlu sonuç verecektir, ama - bu işlem veri segment sınırınızı arttıracak, ve belki de sorgunuzun tamamlanmasını - sağlayacaktır. Bu komut, varolan işleme (current process) ve komut çalıştırıldıktan - sonraki tüm alt işlemlere uygulanır. Eğer SQL istemcinizle, backend'in çok - fazla veri döndürmesi nedeniyle bir sorun yaşıyorsanız, bunu istemciyi başlatmadan - önce deneyiniz.
- -psql arabiriminde, select version(); yazınız.
Large object işlemlerinizin uçlarına, yani lo_open ...
- lo_close komutlarının çevresine, BEGIN WORK ve
- COMMIT koymanız gerekmektedir;
Şu anda, PostgreSQL kuralları large objectleri transaction commit edildiğinde kapatarak - uygulamaktadır. Dolayısıyla handle ile yapılacak ilk şey invalid large obj descriptor hatası - ile sonuçlanacaktır.Dolayısıyla çalışan kodunuz eğer transaction kullanmazsanız hata mesajları - üretecektir.
-Eğer ODBC gibi bir istemci arabirimi kullanıyorsanız, auto-commit'i - kapatmanız gerekebilir.
- -Alttakini kullanabilirsiniz:
--CURRENT_TIMESTAMP: -CREATE TABLE test (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP ); -- -
IN kullanan subquery'lerim
- çok yavas?7.4 sürümünden önce, subqueryler. Eğer subquery sadece birkaç satır ve outer query bol - sayıda satır döndürüyorsa, IN en hızlısıdır. Sorguları hızlandırmak için IN yerine EXISTS - kullanın:
--SELECT * - FROM tab - WHERE col1 IN (SELECT col2 FROM TAB2) --
sorgusunu, aşağıdaki ile değiştirin:
--SELECT * - FROM tab - WHERE EXISTS (SELECT col2 FROM TAB2 WHERE col1 = col2) --
Bu işlemin hızlı olması için, subcol'un indexlenmiş bir kolon olması gerekmektedir.
-7.4 sürümü ve sonrasında, IN aslında normal sorgularla aynı karmaşık join tekniklerini kullanır ve - EXISTS'e tercih edilir.
- -PostgreSQL outer joins islemlerini SQL standartlarını kullanarak - gerçekleştirmektedir. Aşağıda 2 örnek bulunmaktadır:
--SELECT * -FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); --
ya da
--SELECT * -FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col); --
Bu özdeş sorgular t1.col' i t2.col'ye join ederler ve aynı zamanda t1'deki
- unjoined satırları (t2'de eşlenmemiş olanlarla) döndürürler. RIGHT
- JOIN t2'nin unjoined satırlarını ekleyecektir. Bir FULL join, eşleşmiş
- bütün satırları ve t1 ile t2'den tüm bağlanmamış (unjoined) satırları alır.
- OUTER sözcüğü seçimseldir ve LEFT, RIGHT ve
- FULL join işlemlerinde olduğu kabul edilir. Sıradan join
- işlemleri INNER JOIN olarak adlandırılır.
Önceki sürümlerde, OUTER JOINler UNION ve NOT IN
- kullanılarak simüle edilebiliyordu. Örneğin, tab1 ve tab2'yi birleştirirken, aşağıdaki
- sorgu iki tablonun dıştan bağlanmasını sağlar:
-SELECT tab1.col1, tab2.col2 -FROM tab1, tab2 -WHERE tab1.col1 = tab2.col1 -UNION ALL -SELECT tab1.col1, NULL -FROM tab1 -WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2) -ORDER BY col1 -- -
Mevcut veritabanınız dışındaki başka bir veritabanınızı sorgulamanızın - bir yolu bulunmamaktadır. Bunun nedeni, PostgreSQL'in veritabanına özel sistem - katalogları yüklemesidir. Bu nedenle, cross-database bir sorgunun nasıl - davranacağını kestirmek zordur.
-contrib/dblink fonksiyon çağrılarını kullanarak cross-database sorgulara - izin verir. Tabii ki, bir istemci değişik veritabanlarına aynı anda erişim - sağlayabilir ve bilgiyi bu şekilde birleştirebilir.
- -7.3 sürümünde, bir fonksiyondan kolaylıkla çoklu satır ya da sütun - döndürebilirsiniz. - (http://techdocs.postgresql.org/guides/SetReturningFunctions)
- -PL/PgSQL fonksiyon içerikleri cache'ler. Bunun istenmeyen bir tarafı,
- eğer bir PL/PgSQL fonksiyonu geçici bir tabloya erişiyorsa ve bu tablo ileride
- kaldırılıp yeniden oluşturulduktan sonra fonksiyon yeniden çağrılırsa, fonksiyon
- çalışmayacaktır; çünkü cache'lenmiş fonksiyon hala eski geçici tabloyu
- gösteriyor olacaktır. Çözüm, geçici tablo erişimleri için PL/PgSQL'de
- EXECUTE kullanmaktır. Bu, sorgunun her seferinde yeniden işlenmesini
- sağlayacaktır.
Sorunun nedeni birden fazla şey olabilir. Kullanıcı-tanımlı fonksiyonunuzu - stand-alone bir programda çalıştırmayı deneyiniz.
- -Çalışmalarınızı pgsql-hackers e-posta listesine gönderiniz. Kodunuz - incelendikten sonra contrib dizinine konacaktır.
- -PostgreSQL 7.3 sürümü ile birlikte, C, PL/PgSQL ve SQL kullanılarak tablo-döndüren - fonksiyonlar tamamen desteklenmektedir. Ayrıntılı bilgi için - PostgreSQL 7.3.2 - Kullanıcı Rehberi'ne bakabilrisiniz. Bir örneği contrib/tablefunc - içinde bulabilirsiniz.
- -Makefile'lar include dosyaları için tam bir bağımlılık içermezler. - Öncelikle make clean, ardından da baska bir make işlemi yapmanız gerekir. - GCC kullanıyorsanız, configure betiğinin --enable-depend seçeneğini, derleyicinin - bağımlılıkları otomatik olarak hesaplaması için kullanabilirsiniz.
- - diff --git a/doc/src/FAQ/README b/doc/src/FAQ/README deleted file mode 100644 index c3e78e0b312..00000000000 --- a/doc/src/FAQ/README +++ /dev/null @@ -1,4 +0,0 @@ -The FAQ* files in this directory are the master versions, and the -../../FAQ* text files are created using lynx: - - lynx -force_html -dont_wrap_pre -dump -hiddenlinks=ignore -nolist FAQ* -- cgit v1.2.3