text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

    <META name="generator" content="HTML Tidy, see www.w3.org">
    <META http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    <TITLE>FAQ do PostgreSQL</TITLE>

Perguntas Frequentes (FAQ) sobre PostgreSQL

Ú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/.

Perguntas Gerais

     1.1) O que é PostgreSQL? Como ele é pronunciado?
     O que é Postgres?

     1.2) Quem controla o PostgreSQL?

     1.3) Qual é a licença do PostgreSQL?

     1.4) Quais plataformas o PostgreSQL pode ser executado?

     1.5) Onde eu posso conseguir o PostgreSQL?

     1.6) Qual é a última versão?

     1.7) Onde eu posso conseguir suporte?

	 1.8) Como eu posso submeter um relato de um bug?

     1.9) Como eu posso saber quais são os bugs conhecidos ou características ausentes?

     1.10) Que documentação está disponível?

     1.11) Como eu posso aprender SQL?

     1.12) Como posso submeter uma correção (patch) ou me juntar a equipe de desenvolvimento?

     1.13) Como é o PostgreSQL comparado a outros SGBDs?

		 1.14) O PostgreSQL gerenciará as mudanças de horário devido ao horário de verão em vários países?

Perguntas sobre Clientes

	 2.1) Quais interfaces estão disponíveis para PostgreSQL?

     2.2) Quais ferramentas estão disponíveis para utilizar o PostgreSQL com páginas Web?

     2.3) O PostgreSQL tem interfaces gráficas para interagir com usuário?

Perguntas Administrativas

    3.1) Como eu instalo o PostgreSQL em um local diferente de /usr/local/pgsql?

	3.2) Como eu controlo conexões de outras máquinas?

    3.3) Como eu ajusto o servidor de banco de dados para obter uma performance melhor?

    3.4) Quais características de depuração estão disponíveis?

    3.5) Por que eu recebo "Sorry, too many clients" quando eu tento conectar?

    3.6) Qual é o processo de atualização do PostgreSQL?

    3.7) Que tipo de hardware eu devo usar?

Perguntas Operacionais

     4.1) Como eu faço um SELECT somente dos primeiros registros de uma consulta? Um registro randômico?

	 4.2) Como eu descubro quais tabelas, índices, bancos de dados e usuários estão definidos? Como eu vejo as consultas utilizadas pelo psql para mostrá-los?

     4.3) Como você muda o tipo de dado de uma coluna?

     4.4) Qual é o tamanho máximo de um registro, uma tabela e um banco de dados?

     4.5) Quanto espaço em disco é necessário para armazenar dados de um arquivo texto?

     4.6) Por que minhas consultas estão lentas? Por que elas não estão utilizando meus índices?

     4.7) Como eu vejo como o otimizador de consultas está avaliando minha consulta?

	 4.8) Como eu faço buscas com expressões regulares e buscas com expressões regulares sem diferenciar mauúsculas de minúsculas? Como eu utilizo um índice para buscas sem distinguir maiúsculas de minúsculas?

	 4.9) Em uma consulta, como eu detecto se um campo é NULL? Como eu posso concatenar possíveis NULLs? Como eu posso ordenar por um campo que é NULL ou não?

    4.10) Qual é a diferença entre os vários tipos de dado de caracteres?

	4.11.1) Como eu crio um campo serial/auto incremento?

    4.11.2) Como eu consigo o valor de um campo
    SERIAL?

    4.11.3) currval() não lida com condição de corrida com outros usuários?

    4.11.4) Por que os números da minha sequência não são reutilizados quando uma transação é abortada? Por que há intervalos nos números da minha sequência/coluna SERIAL?

    4.12) O que é um OID? O que é um CTID?

    4.13) Por que eu recebo o erro "ERROR: Memory exhausted in AllocSetAlloc()"?

    4.14) Como eu informo qual versão do PostgreSQL eu estou utilizando?

    4.15) Como eu crio uma coluna que conterá por padrão a hora atual?

    4.16) Como eu faço uma junção externa (outer join)?

    4.17) Como eu faço consultas utilizando múltiplos bancos de dados?

    4.18) Como eu retorno múltiplos registros ou colunas de uma função?

	4.19) Por que eu obtenho erros "relation with OID ######
	does not exist" ao acessar tabelas temporárias em funções PL/PgSQL?

    4.20) Quais soluções de replicação estão disponíveis?

	4.21) Por que os nomes de minhas tabelas e colunas não
	são reconhecidos em minha consulta? Por que as maiúsculas não são preservadas?

Perguntas Gerais

1.1) O que é PostgreSQL? Como ele é pronunciado? O que é Postgres?

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'.

1.2) Quem controla o PostgreSQL?

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.

1.3) Qual é a licença 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-2008, 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.

1.4) Quais plataformas o PostgreSQL pode ser executado?

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.

1.5) Onde eu posso conseguir o PostgreSQL?

Via navegador web, utilize
	http://www.postgresql.org/ftp/ e via ftp, utilize

	ftp://ftp.postgresql.org/pub/.

1.6) Qual é a última versão?

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.

1.7) Onde eu posso conseguir suporte?

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.

1.8) Como eu informo a existência de um bug?

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:

Não é um bug e o porquê

É um bug conhecido e já está na lista de
	AFAZERES

O bug foi corrigido na versão atual

O bug foi corrigido mas não foi empacotado em um versão oficial

Um pedido foi feito para obter informações detalhadas:

Sistema Operacional

Versão do PostgreSQL

Exemplo de teste que reproduz o bug

Informações sobre depuração

Saída reconstituidora de vestígios (backtrace) do depurador

O bug é novo. O seguinte pode ocorrer:

Uma correção é criada e será incluída na próxima versão

O bug não pode ser corrigido imediatamente e é adicionado
	a lista de AFAZERES

1.9) Como eu posso saber quais são os bugs conhecidos
	ou funcionalidades ausentes?

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:

A funcionalidade já está na lista de AFAZERES

A funcionalidade não é desejável porque:

Ela duplica uma funcionalidade existente que já segue o
		padrão SQL

A funcionalidade aumentará a complexidade do código mas
		adicionará pouco benefício

A funcionalidade será insegura ou não-confiável

A nova funcionalidade é adicionada a lista de
	AFAZERES

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.

1.10) Que documentação está disponível?

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.

1.11) Como eu posso aprender SQL?

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:

 http://www.intermedia.net/support/sql/sqltut.shtm

    http://sqlcourse.com

    http://www.w3schools.com/sql/default.asp

http://mysite.verizon.net/Graeme_Birchall/id1.html

1.12) Como posso submeter uma correção (patch) ou me juntar a equipe de desenvolvimento?

Veja a
	FAQ do Desenvolvedor.

1.13) Como é o PostgreSQL comparado a outros SGBDs?

Há várias maneiras de se medir um software: funcionalidades, performance, confiabilidade, suporte e preço.

Funcionalidades

PostgreSQL tem muitas características presentes em muitos SGBDs comerciais como transações, subconsultas, gatilhos, visões, integridade referencial de chave estrangeira e bloqueio (lock) sofisticado. Nós temos algumas funcionalidades que eles não tem, como tipos definidos pelo usuário, herança, regras e controle de concorrência de múltiplas versões para reduzir bloqueios (locks).

Performance

A performance do PostgreSQL é comparável a outros bancos de dados comerciais e de código livre. Ele é mais rápido em algumas coisas, mais lento em outras. Nossa performance é geralmente +/- 10% comparada a de outros bancos de dados.

Confiabilidade

Nós sabemos que um SGBD deve ser confiável ou ele é inútil. Nós empenhamos em lançar versões bem testadas, de código estável e que tenha o mínimo de bugs. Cada versão tem no mínimo um mês de teste em versão beta, e nosso histórico de versões mostra que nós podemos fornecer versões estáveis e sólidas que estão prontas para uso em produção. Nós acreditamos que somos comparados a nosso favor com outros sistemas de bancos de dados nessa área.

Suporte

Nossas listas de discussão fornecem contato com um grupo de desenvolvedores e usuários para ajudar a resolver muitos problemas encontrados. Enquanto nós não podemos garantir o conserto, SGBDs comerciais nem sempre fornecem também. Com acesso direto aos desenvolvedores, a comunidade de usuários, manuais e o código fonte faz com que o suporte do PostgreSQL seja superior ao de outros SGBDs. Há suporte comercial por incidente disponíveis para aqueles que precisam de um. (Veja seção 1.7 da FAQ).

Preço

Nós somos livres para uso dele tanto comercial quanto não comercial. Você pode adicionar nosso código ao seu produto sem limitações, exceto aquelas descritas na nossa licença BSD mencionada acima.

1.14) O PostgreSQL gerenciará mudanças no horário devido ao horário de verão em vários países?

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.

Perguntas sobre Clientes

2.1) Quais interfaces estão disponíveis para PostgreSQL?

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.

2.2) Quais ferramentas estão disponíveis para utilizar o PostgreSQL com páginas Web?

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.

2.3) O PostgreSQL tem interfaces gráficas para iteragir com o usuário?

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

Perguntas Administrativas

3.1) Como eu instalo o PostgreSQL em um local diferente de /usr/local/pgsql?

Especifique a opção --prefix quando executar o configure.

3.2) Como eu controlo conexões de outras máquinas?

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.

3.3) Como eu ajusto o servidor de banco de dados para obter uma performance melhor?

Há três grandes áreas para melhorar a performance em potencial:

Mudança de Consultas

Isto involve modificar consultas para obter melhor performance:

Criação de índices, incluir expressões e índices parciais

Utilização o COPY ao invés de múltiplos comandos INSERTs

Agrupamento de múltiplos comandos em uma única transação para diminuir
	a despesa com efetivações (commit)

Utilização do CLUSTER quando recuperar vários registros de
	um índice

Utilização do LIMIT para retornar um subconjunto da saída
	da consulta

Utilização de Consultas preparadas

Utilização de ANALYZE para manter as estatísticas do
	otimizador corretas

Utilização regular do VACUUM ou pg_autovacuum

Remoção de índices durante grande mudança de dados

Configuração do Servidor

Um grande número de configurações que afetam a performance.
	Para obter detalhes adicionais, veja
    Administration Guide/Server Run-time Environment/Run-time
	Configuration para listagem completa, e para
	comentários veja
    http://www.varlena.com/varlena/GeneralBits/Tidbits/annotated_conf_e.html
    e
    http://www.varlena.com/varlena/GeneralBits/Tidbits/perf.html.

Seleção do Hardware

O efeito do hardware na performance é detalhado em

    http://www.powerpostgresql.com/PerfList/ e
    http://momjian.us/main/writings/pgsql/hw_performance/index.html.

3.4) Quais características de depuração estão disponíveis?

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.

3.5) Por que eu recebo "Sorry, too many clients" quando eu tento conectar?

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.

3.6) Qual é o processo de atualização do PostgreSQL?

Veja http://www.postgresql.org/support/versioning
	para discussão geral sobre atualizações e
	http://www.postgresql.org/docs/current/static/install-upgrading.html
	para instruções específicas.

3.7) Que tipo de hardware eu devo usar?

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.

Perguntas Operacionais

4.1) Como eu faço um SELECT somente dos primeiros registros de uma consulta? Um registro randômico?

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;

4.2) Como eu descubro quais tabelas, índices, bancos de dados e usuários estão definidos? Como eu vejo as consultas utilizadas pelo psql para mostrá-los?

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.

4.3) Como você muda o tipo de dado de uma coluna?

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.

4.4) Qual é o tamanho máximo de um registro, uma tabela e um banco de dados?

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.

4.5) Quanto espaço em disco é necessário para armazenar dados de um arquivo texto?

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.

4.6) Por que minhas consultas estão lentas? Por que elas não estão utilizando meus índices?

Í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:

O início da cadeia de caracteres da busca deve ser iniciar com uma
	cadeia de caracteres, i.e.

modelos LIKE não devem iniciar com %.

modelos ~ (expressões regulares) devem iniciar com ^.

A cadeia de caracteres utilizada na busca não pode iniciar com a classe de
	caracteres e.g. [a-e].

Busca que não diferenciam maiúsculas de minúsculas tais como ILIKE e
	~* não utilizam índices. Em vez disso, utilize índice de expressão, que
	é descrito na seção 4.8.

O idioma padrão C deve ser usando durante o initdb
	porque não é possível saber o próximo caracter em idiomas que não sejam o C.
	Você pode criar um índice especial 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.

4.7) Como eu vejo como o otimizador de consulta está avaliando a minha consulta?

Veja o comando EXPLAIN no manual.

4.8) Como eu faço buscas com expressões regulares
    e buscas com expressões regulares sem diferenciar maiúsculas de minúsculas? Como eu
    utilizo um índice para buscas que não diferenciam maiúsculas de minúsculas?

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.

4.9) Em uma consulta, como eu detecto se um campo é NULL? Como eu posso concatenar possíveis NULLs? Como eu posso ordenar por um campo que é NULL ou não?

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)

4.10) Qual é a diferença entre os vários tipos de dado de caracteres?

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.

4.11.1) Como eu crio um campo serial/auto incremento?

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.

4.11.2) Como eu consigo o valor de um campo
    SERIAL?

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.

4.11.3) currval() não lida com condição de corrida com outros usuários?

Não. currval() retorna o valor atual atribuido pela sua sessão, e não por todas as sessões.

4.11.4) Por que os números da minha sequência não são reutilizados quando uma transação é abortada? Por que há intervalos nos números da minha sequência/coluna SERIAL?

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.

4.12) O que é um OID? O que é um CTID?

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.

4.13) Por que eu recebo o erro "ERROR: Memory exhausted in AllocSetAlloc()"?

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.

4.14) Como eu informo qual versão do PostgreSQL eu estou utilizando?

No psql, digite SELECT version();

4.15) Como eu crio uma coluna que conterá por padrão a hora atual?

Utilize CURRENT_TIMESTAMP:

	CREATE TABLE teste (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP );

4.16) Como eu faço uma junção externa (outer join)?

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).

4.17) Como eu faço consultas utilizando múltiplos bancos de dados?

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.

4.18) Como eu retorno múltiplos registros ou colunas de uma função?

É fácil utilizando funções que retornam conjunto,

	http://www.postgresql.org/docs/techdocs.17.

4.19) Por que eu obtenho erros "relation with OID ######
	does not exist" ao acessar tabelas temporárias em funções PL/PgSQL?

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.

4.20) Quais soluções de replicação estão disponíveis?

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.

4.21) Por que os nomes de minhas tabelas e colunas não
	são reconhecidos em minha consulta? Por que as maiúsculas não são preservadas?

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:

Evitar colocar aspas no identificador ao criar tabelas

Utilizar somente caracteres minúsculos em identificadores

Colocar aspas em identificadores ao referenciá-los nas consultas


text:
script_location=$(dirname $(readlink --canonicalize $0))
. ${script_location}/common.sh

#
# Common functionality for cloud platform test execution engine (test session)
# After sourcing this file the following variables are set:
#
#    SOURCE_DIRECTORY      location of the CernVM-FS sources
#    SERVER_PACKAGE        location of the CernVM-FS server package to test
#    CLIENT_PACKAGE        location of the CernVM-FS client package to test
#    TEST_LOGFILE          location of the test logfile to be used
#    TEST_S3_LOGFILE       location of the test logfile for S3 tests to be used
#    FAKE_S3_LOGFILE       location of the FakeS3 server's output to be used
#    UNITTEST_LOGFILE      location of the unit test logfile to be used
#    MIGRATIONTEST_LOGFILE location of the migration test logfile to be used
#
# Additionally the following configuration variables will be defined:
#    FAKE_S3_PORT          network port to communicate with FakeS3
#    FAKE_S3_STORAGE       storage location of FakeS3
#    FAKE_S3_CONFIG        location of the S3 config file to be created/used
#    FAKE_S3_BUCKET        name of the S3 bucket to be used
#    FAKE_S3_URL           URL to the S3 server
#

SOURCE_DIRECTORY=""
SERVER_PACKAGE=""
CLIENT_PACKAGE=""
TEST_LOGFILE=""
TEST_S3_LOGFILE=""
FAKE_S3_LOGFILE=""
UNITTEST_LOGFILE=""
MIGRATIONTEST_LOGFILE=""

FAKE_S3_PORT=13337
FAKE_S3_STORAGE=/srv/fakes3
FAKE_S3_CONFIG=/etc/cvmfs/fakes3.conf
FAKE_S3_BUCKET=cvmfs_test
FAKE_S3_URL=http://localhost:${FAKE_S3_PORT}/${FAKE_S3_BUCKET}-1-1

usage() {
  local msg=$1

  echo "$msg"
  echo
  echo "Mandatory options:"
  echo " -t <cvmfs source tree>     CernVM-FS source tree location"
  echo " -s <cvmfs server package>  CernVM-FS server package to be tested"
  echo " -c <cvmfs client package>  CernVM-FS client package to be tested"
  echo " -l <test logfile>          logfile to write test results into"
  echo " -i <S3 test logfile>       logfile to write S3 server test results into"
  echo " -j <FakeS3 logfile>        logfile to write FakeS3 server output into"
  echo " -u <unittest logfile>      logfile to write unittest outputs into"
  echo " -m <migrationtest logfile> logfile to write migration test outputs"

  exit 1
}

# parse script parameters (same for all platforms)
while getopts "t:s:c:l:i:j:u:m:" option; do
  case $option in
    t)
      SOURCE_DIRECTORY=$OPTARG
      ;;
    s)
      SERVER_PACKAGE=$OPTARG
      ;;
    c)
      CLIENT_PACKAGE=$OPTARG
      ;;
    l)
      TEST_LOGFILE=$OPTARG
      ;;
    i)
      TEST_S3_LOGFILE=$OPTARG
      ;;
    j)
      FAKE_S3_LOGFILE=$OPTARG
      ;;
    u)
      UNITTEST_LOGFILE=$OPTARG
      ;;
    m)
      MIGRATIONTEST_LOGFILE=$OPTARG
      ;;
    ?)
      shift $(($OPTIND-2))
      usage "Unrecognized option: $1"
      ;;
  esac
done

# check that all mandatory parameters are set
if [ x$SOURCE_DIRECTORY      = "x" ] ||
   [ x$TEST_LOGFILE          = "x" ] ||
   [ x$TEST_S3_LOGFILE       = "x" ] ||
   [ x$FAKE_S3_LOGFILE       = "x" ] ||
   [ x$UNITTEST_LOGFILE      = "x" ] ||
   [ x$MIGRATIONTEST_LOGFILE = "x" ] ||
   [ x$SERVER_PACKAGE        = "x" ] ||
   [ x$CLIENT_PACKAGE        = "x" ]; then
  echo "missing parameter(s), cannot run platform dependent test script"
  exit 100
fi

# check that the script is running under the correct user account
if [ $(id --user --name) != "sftnight" ]; then
  echo "test cases need to run under user 'sftnight'... aborting"
  exit 3
fi

#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#

create_fakes3_config() {
  [ ! -f $FAKE_S3_CONFIG ] || sudo rm -f $FAKE_S3_CONFIG
  sudo tee $FAKE_S3_CONFIG > /dev/null << EOF
CVMFS_S3_HOST=localhost
CVMFS_S3_PORT=$FAKE_S3_PORT
CVMFS_S3_ACCESS_KEY=not
CVMFS_S3_SECRET_KEY=important
CVMFS_S3_BUCKETS_PER_ACCOUNT=1
CVMFS_S3_MAX_NUMBER_OF_PARALLEL_CONNECTIONS=10
CVMFS_S3_BUCKET=$FAKE_S3_BUCKET
EOF
}

start_fakes3() {
  local logfile=$1

  [ ! -d $FAKE_S3_STORAGE ] || sudo rm -fR $FAKE_S3_STORAGE > /dev/null 2>&1 || return 1
  sudo mkdir -p $FAKE_S3_STORAGE                            > /dev/null 2>&1 || return 2
  create_fakes3_config                                      > /dev/null 2>&1 || return 3
  run_background_service $logfile "sudo fakes3 --port $FAKE_S3_PORT --root $FAKE_S3_STORAGE"
}

check_result() {
  local res=$1
  if [ $res -ne 0 ]; then
    echo "Failed!"
  else
    echo "OK"
  fi
}

run_unittests() {
  echo -n "running CernVM-FS unit tests... "
  cvmfs_unittests $@ >> $UNITTEST_LOGFILE 2>&1
  local ut_retval=$?
  check_result $ut_retval

  return $ut_retval
}

redpajama_set_name: RedPajamaGithub


text:
from gevent import monkey
monkey.patch_all()

import unittest2 as unittest
import time

import gevent
import websocket
import zmq.green as zmq

from job_runner_ws_server.runner import run

class WebSocketServerTestCase(unittest.TestCase):
    """
    Tests for the WebSocket server.
    """
    def test_flow(self):
        """
        Test the full event to websocket flow.

        We start the :func:`.run` with the event listener on port 5555 and the
        WebSocket server on port 5000. Then we send an event and check we
        receive it in our WebSocket connection.

        .. note:: The coverage displayed by the coverage tool doesn't play
            nicely with gevent.

        """
        gevent.spawn(run, 5555, 5000)
        time.sleep(1)
        ws = websocket.create_connection('ws://localhost:5000/')

        context = zmq.Context(1)
        publisher = context.socket(zmq.PUB)
        publisher.connect('tcp://localhost:5555')
        publisher.send_multipart(['worker.event', 'foo-bar'])
        self.assertEqual('foo-bar', ws.recv())


text:
'use strict';
import fs from 'fs-extra';
import stream from 'stream';
import zlib from 'zlib';
const Readable = stream.Readable;
import Joi from '@hapi/joi';
import crypto from 'crypto';
import validator from 'is-my-json-valid';
import moment from 'moment';
import path from 'path';
import util from 'util';
import { clone, has, isPlainObject, isString } from './barrel';

const SPACES = 4;
const OK = 'OK';

const confSchema = Joi.object()
  .keys({
    name: Joi.string()
      .min(2)
      .required()
      .description('base name for the configuration file'),
    compression: Joi.string()
      .valid('gz')
      .optional()
      .description('compression algorithm')
      .example('gz'),
    encryption: Joi.string()
      // .valid(crypto.getCiphers())
      .optional()
      .description('encryption algorithm')
      .example('aes-256-cbc'),
    password: Joi.string()
      .min(2)
      .description('password for encryption'),
    schema: [
      Joi.string()
        .min(2)
        .description('json-schema file path'),
      Joi.object().description('json-schema content')
    ],
    baseDirectory: Joi.string()
      .min(2)
      .required()
      .description('parent directory containing the configuration file'),
    relativeDirectory: Joi.string()
      .min(2)
      .optional()
      .description('the child directory containing the configuration file'),
    backupBeforeSave: Joi.boolean()
      .default(false)
      .description('true if the configuration file must be backup before save')
  })
  .with('encryption', ['password']);

export interface ConfitureConfiguration {
  name: string;
  compression?: string;
  encryption?: string;
  password?: string;
  schema: string | object;
  baseDirectory: string;
  relativeDirectory?: string;
  backupBeforeSave?: boolean;
}

const isSchemaFile = (value: any) => {
  return isString(value);
};

const isSchemaContent = (value: any) => {
  return isPlainObject(value);
};

const loadSchema = (value: any) => {
  if (isSchemaContent(value)) {
    return value;
  } else if (isSchemaFile(value)) {
    return fs.readJsonSync(value);
  } else {
    throw new Error('Unknown schema ' + value);
  }
};

const schemaValidator = (value: any) => {
  const schema = loadSchema(value);
  return validator(schema);
};

export interface Confiture {
  configuration(): any;
  load(): any;
  save(conf: object): fs.WriteStream | Error;
  saveSync(conf: object): string | Error;
}
export function confiture(config: ConfitureConfiguration): Confiture {
  const confg = confSchema.validate(config);

  if (typeof confg.error !== 'undefined') {
    throw new Error(confg.error.message);
  }

  const cfg = confg.value;

  const isCompressed = has(cfg, 'compression');
  const isEncrypted = has(cfg, 'encryption');
  const hasRelativeDirectory = has(cfg, 'relativeDirectory');

  const validate = schemaValidator(cfg.schema); // sync

  let content = null;

  const getConfigurationFilename = () => {
    let filename = cfg.name + '.json';
    if (isEncrypted) {
      filename = filename + '.' + cfg.encryption;
    } else if (isCompressed) {
      filename = filename + '.' + cfg.compression;
    }

    return filename;
  };

  const confFilename = getConfigurationFilename();

  cfg.filename = confFilename;

  const filepath = hasRelativeDirectory
    ? path.join(cfg.baseDirectory, cfg.relativeDirectory, confFilename)
    : path.join(cfg.baseDirectory, confFilename);

  cfg.filepath = filepath;

  const backup = () => {
    const suffix = moment().format();
    const backupFilepath = filepath + '.bak-' + suffix;
    try {
      fs.renameSync(filepath, backupFilepath);
    } catch (e) {
      console.error(e);
    }
  };

  const loadJson = () => {
    const jsonToCheck = fs.readJsonSync(filepath);
    return jsonToCheck;
  };

  const loadCompressedJson = () => {
    const compressed = fs.readFileSync(filepath);
    const uncompressed = zlib.gunzipSync(compressed).toString();
    const jsonToCheck = JSON.parse(uncompressed);
    return jsonToCheck;
  };

  const loadEncryptedJson = () => {
    const encrypted = fs.readFileSync(filepath);
    const decipher = crypto.createDecipher(cfg.encryption, cfg.password);
    let dec = decipher.update(encrypted, undefined, 'utf8');
    dec += decipher.final('utf8');
    const jsonToCheck = JSON.parse(dec);
    return jsonToCheck;
  };

  const load = () => {
    let loaded = null;
    if (isEncrypted) {
      loaded = loadEncryptedJson();
    } else if (isCompressed) {
      loaded = loadCompressedJson();
    } else {
      loaded = loadJson();
    }

    if (!validate(loaded)) {
      return new Error(
        util.format('Failed validation while loading: %j', validate.errors)
      );
    }

    content = loaded;
    return content;
  };

  const saveJson = (wishedJson: object) => {
    const jsonStr = JSON.stringify(wishedJson, null, SPACES);
    const wstream = fs.createWriteStream(filepath);
    wstream.write(jsonStr);
    return wstream;
  };

  const saveJsonSync = (wishedJson: object) => {
    try {
      fs.writeJsonSync(filepath, wishedJson, { spaces: SPACES });
      return OK;
    } catch (err) {
      return err;
    }
  };

  const stringReader = (str: string) => {
    const r = new Readable();
    r._read = () => {
      r.push(str);
      r.push(null);
    };
    return r;
  };

  const saveCompressedJson = (wishedJson: object) => {
    const jsonStr = JSON.stringify(wishedJson, null, SPACES);
    const rstream = stringReader(jsonStr);
    const zipstream = cfg === 'gz' ? zlib.createGzip() : zlib.createGzip(); // TODO (zip?)
    const wstream = fs.createWriteStream(filepath);
    rstream.pipe(zipstream).pipe(wstream);
    return wstream;
  };

  const saveCompressedJsonSync = (wishedJson: object) => {
    const jsonStr = JSON.stringify(wishedJson, null, SPACES);
    try {
      const compressed = zlib.gzipSync(jsonStr);
      fs.writeFileSync(filepath, compressed);
      return OK;
    } catch (err) {
      return err;
    }
  };

  const saveEncrypedJson = (wishedJson: object) => {
    const jsonStr = JSON.stringify(wishedJson, null, SPACES);
    const rstream = stringReader(jsonStr);
    const encryptor = crypto.createCipher(cfg.encryption, cfg.password);
    const wstream = fs.createWriteStream(filepath);
    rstream.pipe(encryptor).pipe(wstream);
    return wstream;
  };

  const saveEncrypedJsonSync = (wishedJson: object) => {
    const jsonStr = JSON.stringify(wishedJson, null, SPACES);
    const encryptor = crypto.createCipher(cfg.encryption, cfg.password);
    try {
      let enc = encryptor.update(jsonStr, 'utf8', 'hex');
      enc += encryptor.final('hex');
      const buff = new Buffer(enc, 'hex');
      fs.writeFileSync(filepath, buff);
      return OK;
    } catch (err) {
      return err;
    }
  };

  const confDirectory = hasRelativeDirectory
    ? path.join(cfg.baseDirectory, cfg.relativeDirectory)
    : cfg.baseDirectory;
  const ensureDirectory = () => {
    fs.ensureDir(confDirectory);
  };

  const save = (wishedJson: object): fs.WriteStream | Error => {
    if (!validate(wishedJson)) {
      return new Error(
        util.format('Failed validation while saving: %j', validate.errors)
      );
    }
    ensureDirectory();

    if (cfg.backupBeforeSave) {
      backup();
    }
    content = wishedJson;
    let rstream = null;

    if (isEncrypted) {
      rstream = saveEncrypedJson(wishedJson);
    } else if (isCompressed) {
      rstream = saveCompressedJson(wishedJson);
    } else {
      rstream = saveJson(wishedJson);
    }

    return rstream;
  };

  const saveSync = (wishedJson: object) => {
    if (!validate(wishedJson)) {
      return new Error(
        util.format('Failed validation while saving: %j', validate.errors)
      );
    }
    ensureDirectory();

    if (cfg.backupBeforeSave) {
      backup();
    }
    content = wishedJson;
    let saveResult = OK;

    if (isEncrypted) {
      saveResult = saveEncrypedJsonSync(wishedJson);
    } else if (isCompressed) {
      saveResult = saveCompressedJsonSync(wishedJson);
    } else {
      saveResult = saveJsonSync(wishedJson);
    }

    return saveResult;
  };

  const getConfiguration = () => {
    return clone(cfg);
  };

  return {
    configuration: getConfiguration,
    load,
    save,
    saveSync
  };
}


text:
using UnityEngine;
using UnityEngine.UI;
using System.Collections;

public class NumberWizard : MonoBehaviour {

    public int randomNumber;

    public int min = 1;
    public int max = 1000;
    public int guess = 500;

    public int maxGuessesAllowed = 10;

    public Text scoreDisplay;

    public AudioSource up;
    public AudioSource down;

	// Use this for initialization
	void Start () {
        StartGame();
    }

    void StartGame()
    {
        min = 1;
        max = 1000;
        NextGuess();

        max = max + 1;
    }

    public void GuessHigher()
    {
        up.Play();
        min = guess;
        NextGuess();
    }

    public void GuessLower()
    {
        down.Play();
        max = guess;
        NextGuess();
    }

    void GenerateGuess()
    {
        int typeGuess = Random.Range(0, 3);

        // Rational guess
        if (typeGuess == 0)
        {
            guess = (max + min) / 2;
        }
        // Random guess
        else if (typeGuess == 1)
        {
            guess = Random.Range(min, max + 1);
        }
        // Semi-rational
        else
        {
            int deviation = (int)Mathf.Ceil((max - min) / 5);
            int plusOrMinus = Random.Range(0, 2);
            if (plusOrMinus == 0) deviation = -deviation;
            guess = (max + min + 1) / 2 + deviation;
        }

        scoreDisplay.text = guess.ToString();
    }

    void NextGuess()
    {
        GenerateGuess();
        maxGuessesAllowed = maxGuessesAllowed - 1;
        if(maxGuessesAllowed <= 0)
        {
            Application.LoadLevel("Win");
        }
    }

	// Update is called once per frame
	void Update () {

    }
}


text:
package it.unibz.krdb.obda.owlrefplatform.core.queryevaluation;

import java.sql.Types;

public class DB2SQLDialectAdapter extends SQL99DialectAdapter {

	@Override
	public String strconcat(String[] strings) {
		if (strings.length == 0)
			throw new IllegalArgumentException("Cannot concatenate 0 strings");
		if (strings.length == 1)
			return strings[0];
		StringBuilder sql = new StringBuilder();

		sql.append(String.format("(%s", strings[0]));
		for (int i = 1; i < strings.length; i++) {
			sql.append(String.format(" || %s", strings[i]));
		}
		sql.append(")");
		return sql.toString();
	}

	@Override
	public String sqlSlice(long limit, long offset) {
		if (limit < 0 || limit == 0) {
			if (offset < 0) {
				// If both limit and offset is not specified.
				return "";
			} else {
				// The max number of rows is specified by the development team.
				return String.format("LIMIT 8000\nOFFSET %d", offset);
			}
		} else {
			if (offset < 0) {
				// If the offset is not specified
				return String.format("LIMIT %d\n", limit);
			} else {
				return String.format("LIMIT %d\nOFFSET %d", limit, offset);
			}
		}
	}

	@Override
	public String sqlCast(String value, int type) {
		String strType = null;
		if (type == Types.VARCHAR) {
			strType = "VARCHAR(500)";
		} else {
			throw new RuntimeException("Unsupported SQL type");
		}
		return "CAST(" + value + " AS " + strType + ")";
	}
}


text:
use std::fmt;

#[derive(Debug, Eq, PartialEq)]
/// A message source.
pub enum Source {
    /// A server message source.
    Server {
        /// The server's hostname.
        host: String,
    },
    /// A user message source.
    User {
        /// The user's nickname.
        nick: String,
        /// The user's identifier.
        ident: String,
        /// The user's hostname.
        host: String,
    },
}

impl fmt::Display for Source {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Source::Server { ref host } => write!(f, "{}", host),
            Source::User {
                ref nick,
                ref ident,
                ref host,
            } => write!(f, "{}!{}@{}", nick, ident, host),
        }
    }
}

#[derive(Debug, Eq)]
/// The kind of a message.
pub enum MessageKind {
    /// A command.
    ///
    /// Commands are case-insensitive.
    Command(String),
    /// A numeric reply to a command, consisting of a 3-digit number.
    Numeric(u16),
}

impl fmt::Display for MessageKind {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            MessageKind::Command(ref c) => write!(f, "{}", c.to_ascii_uppercase()),
            MessageKind::Numeric(n) => write!(f, "{:03}", n),
        }
    }
}

impl PartialEq for MessageKind {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (&MessageKind::Command(ref l), &MessageKind::Command(ref r)) => {
                l.eq_ignore_ascii_case(r)
            }
            (&MessageKind::Numeric(ref l), &MessageKind::Numeric(ref r)) => l == r,
            _ => false,
        }
    }
}


text: This is the code for the recommendation system running on hadoop2.x.


text:
"""This file defines api serializer methods to represent bucketlist details."""

from rest_framework import serializers
from bucketlist.models import Bucketlist, Bucketlistitem

class BucketlistitemSerializer(serializers.ModelSerializer):
    """Define bucketlistitems serializer fields."""

    class Meta:
        model = Bucketlistitem
        fields = ('id', 'name', 'done', 'bucketlist',
                  'created_at', 'updated_at')
        read_only_fields = ('id', 'created_at', 'updated_at')

class BucketlistSerializer(serializers.ModelSerializer):
    """Define bucketlist fields that will be serialized."""

    creator = serializers.ReadOnlyField(source='creator.username')
    items = BucketlistitemSerializer(many=True, read_only=True)

    class Meta:
        model = Bucketlist
        fields = ('id', 'name', 'creator', 'created_at', 'updated_at', 'items')

        read_only_fields = ('created_at', 'updated_at', 'items')


text:
{-# LANGUAGE CPP                       #-}
{-# LANGUAGE DeriveDataTypeable        #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE FlexibleInstances         #-}
{-# LANGUAGE FunctionalDependencies    #-}
{-# LANGUAGE MultiParamTypeClasses     #-}
{-# LANGUAGE RankNTypes                #-}
{-# LANGUAGE RecordWildCards           #-}
{-# LANGUAGE TypeFamilies              #-}
{-# LANGUAGE AllowAmbiguousTypes          #-}

{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}

module Plots.Types.Smooth
  (  -- * General smooth plot
     GSmoothPlot
  , _SmoothPlot

    -- * Smooth plot
  , SmoothPlot
  , mkSmoothPlotOf
  , mkSmoothPlot

    -- * Helper functions
  , drawTrail
  , testXY

     -- * Smooth Plot
   , smoothPlot
   , smoothPlot'
   , smoothPlotL
     -- * Fold variant smooth plot
   , smoothPlotOf
   , smoothPlotOf'
   , smoothPlotOfL
  ) where

import           Control.Lens                    hiding (lmap, none, transform,
                                                  ( # ))
import           Control.Monad.State.Lazy
import qualified Data.Foldable                   as F
import           Data.Typeable

import           Diagrams.Prelude
import           Diagrams.Coordinates.Isomorphic

import           Plots.Themes
import           Plots.Types
import           Plots.API

------------------------------------------------------------------------
-- GPoints plot
------------------------------------------------------------------------

data GSmoothPlot v n a = forall s. GSmoothPlot
  { sData :: s
  , sFold :: Fold s a
  , sPos  :: a -> Point v n
  , sMeth :: [P2 n] -> (Located (Trail' Loop V2 n) ,Located (Trail' Line V2 n))
  , sLine :: Bool
  } deriving Typeable

-- Change P2 n to Point v n.
-- Implement sExtend :: Bool.

type instance V (GSmoothPlot v n a) = v
type instance N (GSmoothPlot v n a) = n

instance (Metric v, OrderedField n) => Enveloped (GSmoothPlot v n a) where
  getEnvelope GSmoothPlot {..} = foldMapOf (sFold . to sPos) getEnvelope sData

instance (Typeable a, Typeable b, TypeableFloat n, Renderable (Path V2 n) b)
    => Plotable (GSmoothPlot V2 n a) b where
  renderPlotable s GSmoothPlot {..} pp =
               lp # stroke
                  # lw none
                  # applyBarStyle pp
                  # opacity 0.7
                  # transform t
            <> if sLine
                then ln # transform t # stroke
                else mempty
--  # applyLineStyle pp
--  ln :: Located (Trail' Loop V2 n)
          where
            ps             = toListOf (sFold . to sPos . to (logPoint ls)) sData
            (lp, ln)       = sMeth ps
            t              = s ^. specTrans
            ls             = s ^. specScale

  defLegendPic GSmoothPlot {..} pp
      = square 5 # applyBarStyle pp

_SmoothPlot :: (Plotable (SmoothPlot v n) b, Typeable b)
                   => Prism' (Plot b v n) (SmoothPlot v n)
_SmoothPlot = _Plot

------------------------------------------------------------------------
-- Simple smooth plot
------------------------------------------------------------------------

type SmoothPlot v n = GSmoothPlot v n (Point v n)

-- | Plot a smooth function given data.
mkSmoothPlot :: (PointLike v n p, F.Foldable f, Ord n, Floating n, Enum n, Num n)
              => f p -> SmoothPlot v n
mkSmoothPlot = mkSmoothPlotOf folded

-- | Smooth plot with a given fold.
mkSmoothPlotOf :: (PointLike v n p, Ord n, Floating n, Enum n, Num n)
                => Fold s p -> s -> SmoothPlot v n
mkSmoothPlotOf f a = GSmoothPlot
  { sData = a
  , sFold = f . unpointLike
  , sPos  = id
  , sMeth = testXY
  , sLine = True
  }

------------------------------------------------------------------------
-- Helper functions
------------------------------------------------------------------------

testXY :: (Ord n, Floating n, Enum n) => [P2 n] -> (Located (Trail' Loop V2 n) ,Located (Trail' Line V2 n))
testXY ps = (lp, ln)
  where
    xpts = map fst (map unp2 ps)
    ypts = map snd (map unp2 ps)
    ymean = mean ypts
    xmin = minimum xpts
    xmax = maximum xpts
    ymax = maximum ypts
    h    = 0.3 * (ymax - ymean)
    (m, b) = simpleLinear (map unp2 ps)
    y1   = predict xmin (m, b)
    y2   = predict xmax (m, b)
    lp   = (fromVertices (map p2 [(xmin, y1-h),(xmax, y2-h),(xmax, y2+h),(xmin, y1+h)])) #mapLoc closeLine
    ln   = fromVertices (map p2 [(xmin, y1),(xmax, y2)])

-- add more functions for smooth,
-- lm, rlm, density and so on.

mean :: (Fractional a) => [a] -> a
mean xs = sum(xs) / fromIntegral (length xs)

meanOfPoints :: (Fractional a) => [(a, a)] -> (a, a)
meanOfPoints x = let (a, b) = unzip x
                 in (mean a, mean b)

sq :: Num a => a -> a
sq x = x * x

correlation :: (Floating a) => [(a, a)] -> a
correlation xs = xy / sqrt (xx * yy)
                 where xy = sum $ map (\x -> fst x * snd x) xs
                       xx = sum $ map (\x -> sq (fst x)) xs
                       yy = sum $ map (\x -> sq (snd x)) xs

stdDev :: Floating a => [a] -> a
stdDev xs = sqrt $ sum (xMinusMean xs) / lengthList
            where mu = mean xs
                  xMinusMean = map (\x -> sq (x - mu))
                  lengthList = fromIntegral (length xs)

stdDevOfPoints :: (Floating a) => [(a, a)] -> (a, a)
stdDevOfPoints x = let (a, b) = unzip x
                   in (stdDev a, stdDev b)

simpleLinear :: (Ord n, Floating n, Enum n) => [(n , n)] -> (n, n)
simpleLinear xs = (m, b)
                  where r = correlation xs
                        (sx, sy) = stdDevOfPoints xs
                        (mx, my) = meanOfPoints xs
                        m = r * sy / sx
                        b = my - m * mx

predict :: (Ord n, Floating n, Enum n) => n -> (n, n) -> n
predict x (m, b) = b + m * x

----------------------------------------------------------------------------
-- Smooth Lenses
----------------------------------------------------------------------------

class HasSmooth a v n d | a -> v n, a -> d where
  smooth :: Lens' a (GSmoothPlot v n d)

  drawTrail :: Lens' a Bool
  drawTrail =  smooth . lens sLine (\s b -> (s {sLine = b}))

instance HasSmooth (GSmoothPlot v n d) v n d where
  smooth = id

instance HasSmooth (PropertiedPlot (GSmoothPlot v n d) b) v n d where
  smooth = _pp

------------------------------------------------------------------------
-- Smooth Plot
------------------------------------------------------------------------

-- $ smoothplot
-- smooth plots display data as various functions. There are
-- several representations for smooth plots for extra parameters.
-- Smooth plots have the following lenses:
--
-- @
-- * 'sLine' :: 'Lens'' ('BoxPlot' v n) 'Bool' - False
-- @

-- | Add a 'SmoothPlot' to the 'AxisState' from a data set.
--
-- @
--   myaxis = r2Axis ~&
--     smoothPlot data1
-- @
--
-- === __Example__
--
-- <<plots/smoothsimple.png#diagram=smoothsimple&width=300>>
--
-- @
-- myaxis :: Axis B V2 Double
-- myaxis = r2Axis &~ do
--    smoothPlot mydata1
--    smoothPlot mydata2
--    smoothPlot mydata3
-- @

smoothPlot
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      F.Foldable f ,
      Enum n, TypeableFloat n)
  => f p -> m ()
smoothPlot d = addPlotable (mkSmoothPlot d)

-- | Make a 'SmoothPlot' and take a 'State' on the plot to alter it's
--   options
--
-- @
--   myaxis = r2Axis &~ do
--     smoothPlot' pointData1 $ do
--       sLine .= False
--       addLegendEntry "data 1"
-- @

smoothPlot'
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      F.Foldable f ,
      Enum n, TypeableFloat n)
  => f p -> PlotState (SmoothPlot v n) b -> m ()
smoothPlot' d = addPlotable' (mkSmoothPlot d)

-- | Add a 'SmoothPlot' with the given name for the legend entry.
--
-- @
--   myaxis = r2Axis &~ do
--     smoothPlotL "blue team" pointData1
--     smoothPlotL "red team" pointData2
-- @

smoothPlotL
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      F.Foldable f ,
      Enum n, TypeableFloat n)
  => String -> f p  -> m ()
smoothPlotL l d = addPlotableL l (mkSmoothPlot d)

-- fold variant

smoothPlotOf
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      Enum n, TypeableFloat n)
  => Fold s p -> s -> m ()
smoothPlotOf f s = addPlotable (mkSmoothPlotOf f s)

smoothPlotOf'
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      Enum n, TypeableFloat n)
  => Fold s p -> s -> PlotState (SmoothPlot v n) b -> m ()
smoothPlotOf' f s = addPlotable' (mkSmoothPlotOf f s)

smoothPlotOfL
  :: (v ~ BaseSpace c,
      PointLike v n p,
      MonadState (Axis b c n) m,
      Plotable (SmoothPlot v n) b,
      Enum n, TypeableFloat n)
  => String -> Fold s p -> s -> m ()
smoothPlotOfL l f s = addPlotableL l (mkSmoothPlotOf f s)


text:
<meta charset="UTF-8" />
<meta content="width=device-width,initial-scale=1" name="viewport"/>

DEBUGGING ON

  Preview:
  <input
    type="hidden"
    role="uploadcare-uploader"
    data-crop="4:5"
    preview-step=""
    data-debug-uploads
  />

  Preview images only:
  <input
    type="hidden"
    role="uploadcare-uploader"
    data-crop="4:5"
    data-images-only=""
    preview-step=""
    data-debug-uploads
  />

  Simple:
  <input type="hidden" role="uploadcare-uploader" data-debug-uploads />

  Simple images only:
  <input type="hidden" role="uploadcare-uploader" data-debug-uploads data-images-only="" />

  Multiple:
  <input type="hidden" role="uploadcare-uploader" data-multiple data-debug-uploads />

  Multiple images only:
  <input type="hidden" role="uploadcare-uploader" data-multiple data-debug-uploads data-images-only="" />

DEBUGGING OFF

  Preview:
  <input
    type="hidden"
    role="uploadcare-uploader"
    data-crop="4:5"
    preview-step=""
  />

  Preview images only:
  <input
    type="hidden"
    role="uploadcare-uploader"
    data-crop="4:5"
    data-images-only=""
    preview-step=""
  />

  Simple:
  <input type="hidden" role="uploadcare-uploader" />

  Simple images only:
  <input type="hidden" role="uploadcare-uploader" data-images-only="" />

  Multiple:
  <input type="hidden" role="uploadcare-uploader" data-multiple />

  Multiple images only:
  <input type="hidden" role="uploadcare-uploader" data-multiple data-images-only="" />


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="(C) Copyright 2005" />
<meta name="DC.rights.owner" content="(C) Copyright 2005" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="concept" name="DC.Type" />
<meta name="DC.Title" content="IJ WARNING" />
<meta name="abstract" content="ij displays warning messages to let the user know if behavior might be unexpected. ij warnings are prefixed with "IJ WARNING"." />
<meta name="description" content="ij displays warning messages to let the user know if behavior might be unexpected. ij warnings are prefixed with "IJ WARNING"." />
<meta scheme="URI" name="DC.Relation" content="ctoolsijcomref18998.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="ctoolsijcomref32407" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="commonltr.css" type="text/css" rel="stylesheet" />
<title>IJ WARNING</title>

IJ WARNING

<samp class="codeph">ij</samp> displays warning messages to let the user know if
behavior might be unexpected. <samp class="codeph">ij</samp> warnings are prefixed with
"IJ WARNING".

Parent topic: ij errors


text:
import os

from rogerthat.consts import DEBUG
from rogerthat.rpc import users
from rogerthat.rpc.users import create_logout_url
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template

class ExplorerPage(webapp.RequestHandler):

    def get(self):
        user = users.get_current_user()
        path = os.path.join(os.path.dirname(__file__), 'explorer.html')
        self.response.out.write(template.render(path, {
            'debug':DEBUG,
            'user':user,
            'session':create_logout_url("/")}))


text:
/**
 * Created by Valentino on 12.12.2015..
 */
var twitterApp = angular.module('twitterApp', ['ngMaterial', 'ui.router', 'ui.bootstrap', 'ngMessages', 'credit-cards', 'ngStorage']);

twitterApp.config(function($locationProvider, $stateProvider, $urlRouterProvider){
    $locationProvider.html5Mode(true);

    $urlRouterProvider.otherwise('/home');

    $stateProvider
        .state('home', {
            url: '/home',
            templateUrl: 'modules/partials/index.html',
            controller: 'HomeController'
        })
        .state('index', {
            url: '/first',
            templateUrl: 'modules/partials/first.html',
            controller: 'IndexController'
        })
        .state('users', {
            url: '/index',
            templateUrl: 'modules/partials/users.html',
            controller: 'UsersController'
        })

});


text:
package others.algorithm;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

/**
 */
public class EncodeString {

    @Test
    void testEncode() {
        // Too short. No benefit
        Assertions.assertEquals("", encode(""));
        Assertions.assertEquals("a", encode("a"));
        Assertions.assertEquals("aa", encode("aa"));
        Assertions.assertEquals("ab", encode("ab"));
        Assertions.assertEquals("abc", encode("abc"));

        // Compress
        Assertions.assertEquals("3a", encode("aaa"));
        Assertions.assertEquals("3a4b", encode("aaabbbb"));
        Assertions.assertEquals("3ab5c", encode("aaabccccc"));
    }

    @Test
    void testDecode() {
        Assertions.assertEquals("", decode(""));
        Assertions.assertEquals("a", decode("a"));
        Assertions.assertEquals("aa", decode("aa"));
        Assertions.assertEquals("ab", decode("ab"));
        Assertions.assertEquals("abc", decode("abc"));

        Assertions.assertEquals("aaa", decode("3a"));
        Assertions.assertEquals("aaabbbb", decode("3a4b"));
        Assertions.assertEquals("aaabccccc", decode("3ab5c"));
    }

    public String encode(String word) {
        StringBuilder enc = new StringBuilder();
        int n = word.length();
        for (int i = 1, cnt = 1; i <= n; i++) {
            if (i == n || word.charAt(i - 1) != word.charAt(i)) {
                if (cnt > 1) {
                    enc.append(cnt);
                }
                enc.append(word.charAt(i - 1));
                cnt = 0;
            }
            cnt++;
        }
        return enc.length() < word.length() ? enc.toString() : word;
    }

    public String decode(String word) {
        StringBuilder dec = new StringBuilder();
        for (int i = 0; i < word.length(); i++) {
            if (Character.isDigit(word.charAt(i))) {
                int rep = word.charAt(i) - '0';
                char c = word.charAt(++i);
                while (rep-- > 0) {
                    dec.append(c);
                }
            } else {
                dec.append(word.charAt(i));
            }
        }
        return dec.toString();
    }

}


text:
Go to /etc/apt. Create the file apt.conf if you don't have it there. Write the following lines there.
```bash
#/etc/apt/apt.conf
Acquire::http::proxy "http://username:password@proxyserver:port/";
Acquire::https::proxy "https://username:password@proxyserver:port/";
Acquire::socks::proxy "socks://username:password@proxyserver:port/";
```
Save it. You are done.

check the [origin source](http://askubuntu.com/questions/77449/how-to-configure-proxy-authentication-to-work-with-ubuntu-software-center)


text:
require 'spec_helper'

describe Release do
  subject { Fabricate(:release) }

  its(:files) { should == [{ :length=>88716, :path=>["1175547.png"] }] }
  its(:info_hash) { should == "%CEn%AF%EB%24Ou%F3%FEl%25%AC%A2n%0C%BA%A6%A5%C3%AE" }

  context "#stats_outdated?" do
    let(:release) do
      time_travel_to((APP_CONFIG['update_interval'] + 20).minutes.ago) do
        Fabricate(:release)
      end
    end

    it "should false true if release is outdated" do
      release.send(:stats_outdated?).should eq(true)
    end

    it "should return false if release is fresh" do
      release.title = "New title"
      release.save
      release.send(:stats_outdated?).should eq(false)
    end
  end

  context "#update_stats" do
    let(:outdated_release) do
      time_travel_to((APP_CONFIG['update_interval'] + 20).minutes.ago) do
        Fabricate(:release).tap do |obj|
          obj.stub!(:scrape).and_return("d5:filesd20:\xA8\xD0\xF4\xDE_'\xA2\x8C\x84p\x83\xE7\xCD\xD8];\x88\x91\xE8Zd8:completei1e10:downloadedi0e10:incompletei0eeee")
        end
      end
    end

    let(:fresh_release) { Fabricate(:release) }

    before do
      [outdated_release, fresh_release].each { |release| release.update_stats }
    end

    it "if release outdated" do
      outdated_release.stats.should == { 'complete' => 1, 'downloaded' => 0, 'incomplete' => 0}
    end

    it "should do noting if release is fresh" do
      fresh_release.stats.should == { 'complete' => 0, 'downloaded'=> 0, 'incomplete' => 0 }
    end
  end
end


text:
package metrics

import (
	"log"
	"net"
	"os"
	"time"

	"github.com/rcrowley/go-metrics"
	influxdb "github.com/vrischmann/go-metrics-influxdb"
	"github.com/xpandmmi/biographies/meta"
)

// Service manages the listener and handler for an HTTP endpoint.
type Service struct {
	Config *meta.Config
	err    chan error
	Logger *log.Logger
	//statMap *expvar.Map
}

// NewService returns a new instance of Service.
func NewService(c *meta.Config) *Service {

	s := &Service{
		err:    make(chan error),
		Config: c,
		Logger: log.New(os.Stderr, "[metrics] ", log.LstdFlags),
	}
	return s
}

// Open starts the service
func (s *Service) Open() error {
	s.Logger.Println("Starting Metrics reporting")

	go influxdb.InfluxDB(
		metrics.DefaultRegistry, // metrics registry
		time.Second*10,          // interval
		s.Config.InfluxHost,
		s.Config.InfluxDB,
		s.Config.InfluxUser,
		s.Config.InfluxPass,
	)
	return nil
}

// Close closes the underlying listener.
func (s *Service) Close() error {
	return nil
}

// SetLogger sets the internal logger to the logger passed in.
func (s *Service) SetLogger(l *log.Logger) {
	s.Logger = l
}

// Err returns a channel for fatal errors that occur on the listener.
func (s *Service) Err() <-chan error { return s.err }

// Addr returns the listener's address. Returns nil if listener is closed.
func (s *Service) Addr() net.Addr {
	return nil
}


text:
module TicTacToe.Data.Token where

-- | The Token type. There are only two tokens: the XX and the OO.
data Token
  = X
  | O
  deriving (Eq, Ord, Show)

switch :: Token -> Token
switch X = O
switch O = X


text:
[![GitHub release](https://img.shields.io/github/release/shaungrady/angular-http-etag.svg?style=flat-square)](https://github.com/shaungrady/angular-http-etag/releases)
[![npm](https://img.shields.io/npm/v/angular-http-etag.svg?style=flat-square)](https://www.npmjs.com/package/angular-http-etag)
[![npm](https://img.shields.io/npm/dm/angular-http-etag.svg?style=flat-square)](https://www.npmjs.com/package/angular-http-etag)
[![JS style](https://img.shields.io/badge/js%20style-standard-orange.svg?style=flat-square)](https://standardjs.com/)
[![Travis](https://img.shields.io/travis/shaungrady/angular-http-etag.svg?style=flat-square)](https://travis-ci.org/shaungrady/angular-http-etag)
[![Test Coverage](https://api.codeclimate.com/v1/badges/cd179568de4ea601823f/test_coverage)](https://codeclimate.com/github/shaungrady/angular-http-etag/test_coverage)
[![David](https://img.shields.io/david/shaungrady/angular-http-etag.svg?style=flat-square)](https://david-dm.org/shaungrady/angular-http-etag)
[![David](https://img.shields.io/david/peer/shaungrady/angular-http-etag.svg?style=flat-square)](https://david-dm.org/shaungrady/angular-http-etag?type=peer)

Tested: IE 9+; Edge 13; Chrome 29, 50+; Firefox 46+; Safari 7+; iOS 9.2+; Android 4.4, 5.1.

---

Easy ETag-based caching for `$http` service requests! Increase responsiveness, decrease bandwidth usage.

* Caches ETag headers and sends them back to the server in the `If-None-Match` header.
* Caches response data with flexible cache configuration.
* Support for `$cacheFactory`, `sessionStorage`, and `localStorage` caches out-of-the-box.
* Easily [adaptable][Cache Service Adapters] for other third-party cache services.
* Compatible with AngularJS 1.2–1.6.

**Example Usage:**

``` javascript
angular
  .module('myApp', [
    'http-etag'
  ])
  .config(function (httpEtagProvider) {
    httpEtagProvider
      .defineCache('persistentCache', {
        cacheService: 'localStorage'
      })
  })

  .controller('MyCtrl', function ($http) {
    var self = this

    $http
      .get('/my_data.json', {
        etagCache: 'persistentCache'
      })
      .then(function success (response, itemCache) {
        var data = response.data
        // Modify the data from the server
        data._fullName = data.first_name + ' ' + data.last_name
        // Update the cache with the modified data
        itemCache.set(data)
        // Assign to controller property
        self.fullName = data._fullName
      }, function error (response) {
        if (response.status != 304) alert('Request error')
      })
      // Synchronous method called if request was previously cached
      // status == 'cached'; headers === undefined;
      .ifCached(function (response, itemCache) {
        self.fullName = data._fullName
      })
  })
```

_Need more information on how ETags work? [Read this](http://bitworking.org/news/ETags__This_stuff_matters)._

## Detailed Documentation

- [Service Provider]
- [Service]
- [$http Decorator]
- [Cache Service Adapters]

[Service Provider]: https://github.com/shaungrady/angular-http-etag/blob/master/docs/service_provider.md
[Service]: https://github.com/shaungrady/angular-http-etag/blob/master/docs/service.md
[$http Decorator]: https://github.com/shaungrady/angular-http-etag/blob/master/docs/http_decorator.md
[Cache Service Adapters]: https://github.com/shaungrady/angular-http-etag/blob/master/docs/cache_service_adapters.md

## Quick Guide

### Install Module

``` bash
$ npm install angular-http-etag
```

Or download from [master/release](https://github.com/shaungrady/angular-http-etag/tree/master/release)

### Include Dependency

Include `'http-etag'` in your module's dependencies.

``` javascript
// The node module exports the string 'http-etag'...
angular.module('myApp', [
  require('angular-http-etag')
])
```

``` javascript
// ... otherwise, include the code first then the module name
angular.module('myApp', [
  'http-etag'
])
```

### Define Caches

``` javascript
.config(function ('httpEtagProvider') {
  httpEtagProvider
    .defineCache('persistentCache', {
      cacheService: 'localStorage'
    })
    .defineCache('sessionCache', {
      cacheService: 'sessionStorage'
    })
    .defineCache('memoryCache', {
      cacheService: '$cacheFactory',
      cacheOptions: {
        number: 50 // LRU cache
      },
      deepCopy: true // $cacheFactory copies by reference by default
    })
})
```

If you so desire, you can define your own caches. The default cache uses `$cacheFactory`
and is limited to 25 cache items (Least Recently Used algorithm).

Define the caches you'd like to use by using `defineCache(cacheId[, config])`, passing a cache ID
followed by the cache configuration. The configuration you pass will extend the
default configuration, which can be set using the `setDefaultCacheConfig(config)`
method. If you don't pass a config, a new cache will be defined using the default config.

 _See more in the [Service Provider] documentation._

### Cache Requests

Using the default cache with default configuration and an automatically generated cache itemKey based on the request:

``` javascript
$http.get('/data', {
    etagCache: true
  })
  .then(responseHandler)
  .ifCached(responseHandler)

function responseHandler (response, itemCache) {
  // Differentiating between cached and successful request responses
  var isCached = response.status === 'cached'

  // itemCache is a cache object bound to the cache item associated with this request.
  itemCache.info()
  // { id: 'httpEtagCache',
  //   itemKey: '/data',
  //   deepCopy: false,
  //   cacheResponseData: true,
  //   cacheService: '$cacheFactory',
  //   cacheOptions: { number: 25 } }
}
```

Using a defined cache from the previous section and an automatically generated cache itemKey:

``` javascript
$http.get('/data', {
    etagCache: 'persistentCache'
  })
  .then(responseHandler)
  .ifCached(responseHandler)

function responseHandler (response, itemCache) {
  itemCache.info()
  // { id: 'persistentCache',
  //   itemKey: '/data',
  //   deepCopy: false,
  //   cacheResponseData: true,
  //   cacheService: 'localStorage',
  //   cacheOptions: { number: 25 } }
}
```
Using a defined cache and a specified key for the cache item:

``` javascript
$http.get('/data', {
    etagCache: {
      id: 'persistentCache',
      itemKey: 'whatFineKeyYouHave'
    }
  })
  .then(responseHandler)
  .ifCached(responseHandler)

function responseHandler (response, itemCache) {
  itemCache.info()
  // { id: 'persistentCache',
  //   itemKey: 'whatFineKeyYouHave',
  //   deepCopy: false,
  //   cacheResponseData: true,
  //   cacheService: 'localStorage',
  //   cacheOptions: { number: 25 } }
}
```

The `etagCache` property also accepts a function that returns on of the values
demonstrated; a `boolean`, a `string`, or an `object`.

 _See more in the [$http Decorator] and [Service] documentation._

## Contributing

Write an issue. Then, possibly, hopefully...

1. Fork the repo.
2. Make a branch.
3. Write the code.
3. Write the tests.
3. Run tests. (`npm test`)
3. Open a pull request.


text:
package com.necla.am.zwutils.addon.ObjectTrap.ScalaScript;

import com.necla.am.zwutils.Debugging.ObjectTrap;

public class AddonRegistrar implements ObjectTrap.IForkScriptEngineFactory {

	public static final String SCRIPTENGINE_EXTENSION = "SCALA";

	@Override
	public void Register(ObjectTrap OT) {

		OT.RegisterScriptEngine(SCRIPTENGINE_EXTENSION, new Implementations.CoObject());

	}

}


text:
==========
LightStone
==========

The LightStone mechanic allows you to get the current light level for a block. Right click any block while holding GlowStone Dust to see the light level.

If the light level is high enough that monsters won't spawn, the bar is shown as green. If they are able to spawn at the clicked location, it will be shown as red.

%CONFIG%

%PERMS%


text:
function(MSource_AdjustBoost)
  if(ADJUSTED_BOOST)
    return()
  endif()

  file(GLOB DEPS_DIR ${CMAKE_SOURCE_DIR}/deps/*)

  foreach(DEP ${DEPS_DIR})
    if(DEP MATCHES "boost.*debug")
      set(BOOST_PATH_DEBUG ${DEP})
    endif()
    if(DEP MATCHES "boost.*release")
      set(BOOST_PATH_RELEASE ${DEP})
    endif()
  endforeach()

  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory ${BOOST_PATH_RELEASE}/lib ${BOOST_PATH_DEBUG}/lib)
  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory ${BOOST_PATH_DEBUG}/lib ${BOOST_PATH_RELEASE}/lib)

  set(ADJUSTED_BOOST "TRUE" CACHE BOOL "Boost has been adjusted.")
endfunction()


text:
CNN classifier for Formality in text.

### Cross Validation

In order to run cross validation on a dataset, you can just run:

```bash
make cross-validate-formality.lahiri.dataset NUM_FOLD=10 PROBLEM_TYPE=regression
```

`PROBLEM_TYPE` defines your problem, either regression or classification. Labels for `formality.lahiri.dataset` between -3 to 3 and real-valued. So, you should give `PROBLEM_TYPE=regression`.
`NUM_FOLD` determines how many fold you run for evaluation of the dataset. Important to note that dataset should be in datasets/ directory.

Example for a classification problem:

```
make cross-validate-formality.lahiri.classes.clean.dataset NUM_FOLD=10 PROBLEM_TYPE=classification
```

### Build and Save Model

Assume that we have formality datasets for emails and it is located in `datasets/formality-email`. You can run the following command; build and save a model in `pretrained-models` directory.

```bash
make pretrained-models/formality-email USE_PRETRAINED_EMBEDDINGS=False
```

If you want to use pretrained word embeddings (e.g., Word2Vec) then you can run this:

```bash
make pretrained-models/formality-email
```

### Prediction with Pretrained Models

Assume that you trained a regressor (or classifier) by using formality email datasets as above. By using this pretrained model, we can predict formality scores of the sentences in news domain. In the `datasets` directory, there is a dataset named `formality-news`. Let's use it as our test data.

```bash
make formality-news.pred MODEL_DIR=pretrained-models/formality-email USE_PRETRAINED_EMBEDDINGS=False
```

If you want to use Word2Vec and if you haven't built any model yet, you may remove providing `USE_PRETRAINED_EMBEDDINGS=False` (since default is `True`):

```
make formality-news.pred MODEL_DIR=pretrained-models/formality-email
```

Even you haven't run the command for build a model, `Makefile` finds the dependency path and run the necessary commands for you. Also, it is important that training data for the model building should be somewhat similar with the test data. News and email domains can be significantly different with each other. I used these two datasets just to illustrate the commands.


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<body >
Implementations of various graphs.
</body>
</html>


text:
( function( doc ) {
    'use strict';

    class Router {
        static init() {
            this.mainContainer = app.$( '#page-container' );
            this.path = window.location.pathname;
            this.addEventListners_();
        }

        static addEventListners_() {
            doc.body.addEventListener( 'click', e => this.handleClick_( e ) );
            window.addEventListener( 'popstate', e => this.popstateHandler_( e ) );
        }

        static handleClick_( e ) {
            if ( e.metaKey || e.ctrlKey || e.button !== 0 ) {
                return;
            }

            var node = e.target;
            do {
                if ( node === null || node.nodeName.toLowerCase() === 'a' ) {
                    break;
                }

                node = node.parentNode;
            } while ( node );

            if ( node ) {
                const href = node.href;
                const path = node.getAttribute( 'href' );

                if ( href.indexOf( window.location.hostname ) !== -1 || path === '/' ) {
                    e.preventDefault();

                    if ( path !== this.path ) {
                        this.path = path;
                        app.Nav.close();
                        this.go_( path, true );
                    }
                }
            }
        }

        static go_( path, updateState ) {
            // update push state and
            // log pageview in GA
            if ( updateState ) {
                this.updateState_();
            }

            // fade current page out
            // load new page
            // then fade in the new page
            Promise.all( [
                this.fadePageOut_(),
                this.loadPageContent_( path )
            ] ).then( data => {
                const html = data[1];
                this.mainContainer.innerHTML = html;

                // use request animation to wait for the html to be painted
                requestAnimationFrame( () => {
                    requestAnimationFrame( () => {
                        app.$.eqHeight( this.mainContainer );
                        app.LazyContentHandler.load();
                        app.LazyImgHandler.loadImages();
                        app.GmapInitializer.init();

                        this.fadePageIn_().then( _ => {
                            if ( path !== '/' ) {
                                doc.body.classList.remove( 'home' );
                                doc.body.classList.remove( 'home-top' );
                            }
                            else {
                                doc.body.classList.add( 'home' );
                                doc.body.classList.add( 'home-top' );
                            }
                        } );
                    } );
                } );
            } );
        }

        static fadePageOut_() {
            return new Promise( ( resolve, reject ) => {
                const onTransitionEnd = () => {
                    this.mainContainer.removeEventListener( 'transitionend', onTransitionEnd );
                    resolve();
                };

                this.mainContainer.addEventListener( 'transitionend', onTransitionEnd );
                doc.body.classList.add( 'page-out' );
            } );
        }

        static loadPageContent_( path ) {
            return app.$.fetch( '/api/loadControlContent', {
                body: {
                    controlName: path,
                    url: path
                }
            } ).then( rsp => {
                if ( rsp.success ) {
                    const content = rsp.obj;
                    return content.html;
                }
            } );
        }

        static fadePageIn_() {
            return new Promise( ( resolve, reject ) => {
                const onTransitionEnd = () => {
                    this.mainContainer.removeEventListener( 'transitionend', onTransitionEnd );
                    resolve();
                };

                window.scrollTo( 0, 0 );
                this.mainContainer.addEventListener( 'transitionend', onTransitionEnd );
                doc.body.classList.remove( 'page-out' );
            } );
        }

        static updateState_() {
            history.pushState( { path: this.path }, null, this.path );

            if ( typeof window.ga === 'function' ) {
                window.ga( 'send', 'pageview' );
            }
        }

        static popstateHandler_() {
            if ( history.state && history.state.path ) {
				this.go_( history.state.path );
			}
        }
    }

    app.Router = Router;

}( document ) );


text:
#include <stdlib.h>
#include "erl_driver.h"

typedef struct _erl_drv_data ExitDrvData;

static ExitDrvData *exit_drv_start(ErlDrvPort port, char *command);
static void         exit_drv_stop(ExitDrvData *data_p);
static void         exit_drv_output(ExitDrvData *data_p, char *buf,
				    ErlDrvSizeT len);
static void         exit_drv_finish(void);

static ErlDrvEntry exit_drv_entry = {
    NULL, /* init */
    exit_drv_start,
    exit_drv_stop,
    exit_drv_output,
    NULL, /* ready_input */
    NULL, /* ready_output */
    "exit_drv",
    exit_drv_finish,
    NULL, /* handle */
    NULL, /* control */
    NULL, /* timeout */
    NULL, /* outputv */
    NULL, /* ready_async */
    NULL,
    NULL,
    NULL,
    ERL_DRV_EXTENDED_MARKER,
    ERL_DRV_EXTENDED_MAJOR_VERSION,
    ERL_DRV_EXTENDED_MINOR_VERSION,
    0,
    NULL,
    NULL,
    NULL,
};

DRIVER_INIT(exit_drv)
{
    return &exit_drv_entry;
}

static ExitDrvData *
exit_drv_start(ErlDrvPort port, char *command)
{
    return (ExitDrvData *) port;
}

static void
exit_drv_stop(ExitDrvData *datap)
{

}

static void
exit_drv_output(ExitDrvData *datap, char *buf, ErlDrvSizeT len)
{
    driver_exit((ErlDrvPort) datap, 0);
}

static void
exit_drv_finish(void)
{

}


text: export { default } from 'ember-reveal-js/services/ember-reveal-js';


text:
package org.apache.spark.sql.kafka010

import org.apache.kafka.common.TopicPartition

import org.apache.spark.sql.execution.streaming.{Offset, SerializedOffset}
import org.apache.spark.sql.sources.v2.reader.streaming.{Offset => OffsetV2, PartitionOffset}

/**
 * An [[Offset]] for the [[KafkaSource]]. This one tracks all partitions of subscribed topics and
 * their offsets.
 */
private[kafka010]
case class KafkaSourceOffset(partitionToOffsets: Map[TopicPartition, Long]) extends OffsetV2 {

  override val json = JsonUtils.partitionOffsets(partitionToOffsets)
}

private[kafka010]
case class KafkaSourcePartitionOffset(topicPartition: TopicPartition, partitionOffset: Long)
  extends PartitionOffset

/** Companion object of the [[KafkaSourceOffset]] */
private[kafka010] object KafkaSourceOffset {

  def getPartitionOffsets(offset: Offset): Map[TopicPartition, Long] = {
    offset match {
      case o: KafkaSourceOffset => o.partitionToOffsets
      case so: SerializedOffset => KafkaSourceOffset(so).partitionToOffsets
      case _ =>
        throw new IllegalArgumentException(
          s"Invalid conversion from offset of ${offset.getClass} to KafkaSourceOffset")
    }
  }

  /**
   * Returns [[KafkaSourceOffset]] from a variable sequence of (topic, partitionId, offset)
   * tuples.
   */
  def apply(offsetTuples: (String, Int, Long)*): KafkaSourceOffset = {
    KafkaSourceOffset(offsetTuples.map { case(t, p, o) => (new TopicPartition(t, p), o) }.toMap)
  }

  /**
   * Returns [[KafkaSourceOffset]] from a JSON [[SerializedOffset]]
   */
  def apply(offset: SerializedOffset): KafkaSourceOffset =
    KafkaSourceOffset(JsonUtils.partitionOffsets(offset.json))
}


text: RSS reader for Livejournal


text:
#include "VectorFunction.h"

// Returns the same vector for any position.
class UniformField : public VectorFunction
{
	const ad::Vec4 m_bFieldDir;
	const ad::Vec4 m_eFieldDir;

public:
	UniformField(const ad::Vec4 &bField, const ad::Vec4 &eField) :
		VectorFunction(), m_bFieldDir(bField), m_eFieldDir(eField) {}
	void GetField(ad::Vec4 &outBField, ad::Vec4 &outEField, const ad::Vec4 &position) const override
	{
		outBField = m_bFieldDir;
		outEField = m_eFieldDir;
	}
};

#endif // UNIFORM_FIELD_H


text:
package com.andy

import io.quarkus.test.junit.QuarkusTest
import io.restassured.RestAssured.given
import org.hamcrest.CoreMatchers.`is`
import org.junit.jupiter.api.Test

@QuarkusTest
class BonjourResourceTest {

    @Test
    def testHelloEndpoint() = {
        given()
          .`when`().get("/bonjour")
          .then()
             .statusCode(200)
             .body(`is`("Hello RESTEasy"))
    }

}