Data por extenso

Por vezes surge a necessidade de escrever uma data por extenso,  por exemplo na emissão de documentos como cheques, relatórios, etc.

A procedure abaixo, realiza esta tarefa de forma simples e rápida, permitindo inclusive retornar o dia da semana.


procedure TForm1.Button1Click(Sender: TObject);

var nrdia: Integer;
    diasemana: array[1..7] of String;
    meses: array[1..12] of String;
    dia, mes, ano: Word;
begin


   {Preenchendo o array diasemana com os dias da semana ...}
   diasemana[1]:= 'Domingo';
   diasemana[2]:= 'Segunda-feira';
   diasemana[3]:= 'Terça-feira';
   diasemana[4]:= 'Quarta-feira';
   diasemana[5]:= 'Quinta-feira';
   diasemana[6]:= 'Sexta-feira';
   diasemana[7]:= 'Sábado';


   {Preenchendo o array meses com dos meses do ano ... }
   meses[1]:= 'Janeiro';
   meses[2]:= 'Fevereiro';
   meses[3]:= 'Março';
   meses[4]:= 'Abril';
   meses[5]:= 'Maio';
   meses[6]:= 'Junho';
   meses[7]:= 'Julho';
   meses[8]:= 'Agosto';
   meses[9]:= 'Setembro';
   meses[10]:= 'Outubro';
   meses[11]:= 'Novembro';
   meses[12]:= 'Dezembro';


   {Decodificando a data }
   DecodeDate(DateTimePicker1.Date ,ano,mes,dia);
   nrdia:= DayOfWeek(DATE);


   {Exibindo a data por extenso em uma Edit }
   Edit1.Text:= diasemana[nrdia]+', '+INTTOSTR(dia)+' de '+meses[mes]+' de '+INTTOSTR(ano);
end;

Esta é um a dica super simples, mas bastante funcional:

Abraço e até o próximo post.

Importando arquivo CSV (Texto Delimitado)

A procedure abaixo listada permite ler qualquer arquivo de texto delimitado, quer seja por virgula, ponto e vírgula ou qualquer outro delimitador. Para tanto basta informar corretamente o delimitador na função aninhada MontaValor.
No exemplo abaixo as informações contidas no arquivo texto serão gravadas em dois ClientDataSet.

procedure TForm1.ImportarCSV;
var ArquivoCSV : TextFile;
    Contador, I : Integer;
    Linha : String;


  // Lê Linha e Monta os valores
  function MontaValor : String;
  var ValorMontado : String;
  begin
     ValorMontado := '';
     inc(I);
     While Linha[I] >= ' ' do
     begin
        If Linha[I]= ';' then  // vc pode usar qualquer delimitador ... eu estou usando o ";"
        break;
        ValorMontado := ValorMontado + Linha[I];
        inc(I);
     end;
     result := ValorMontado;
  end;


begin
   // Carregando o arquivo ...
   AssignFile(ArquivoCSV, 'c:\Nome_do_Arquivo');


   try
      Reset(ArquivoCSV);
      Readln(ArquivoCSV, Linha);
      Contador := 1;


      while not Eoln(ArquivoCSV) do
      begin
         if Contador = 1 then  // Primeira Linha do arquivo (Pedido);
         begin
            I := 0;
            cdsPedido.Append;
            cdsPedidoCodigoCliente.AsString  := MontaValor;
            cdsPedidoNomeDoCliente.AsString := MontaValor;
            cdsPedido.Post;
         end
         else
         begin
            // Demais Linhas (Itens do Pedido )
            I := 0;


            cdsItensDoPedido.Append;
            cdsItensDoPedidoCodigoProduto.AsString := MontaValor;
            cdsItensDoPedidoNomeDoProduto.AsString := AnsiUpperCase(MontaValor);
            cdsItensDoPedidoQuantidade.AsFloat     := StrToFloat(MontaValor);
            cdsItensDoPedidoPreco.AsCurrency       := StrToCurr(MontaValor);
            cdsItensDoPedido.Post;
         end;


         Readln(ArquivoCSV, Linha);
         Contador := Contador + 1;
      end;


   finally
      CloseFile(ArquivoCSV);
   end;


end;


Um grande abraço e até o próximo post.

Guerra Eletrônica

acompanhando os noticiários sobre os conflitos na Libia, deparei-me com uma matéria que repoduzo parcialmente abaixo. O que me chamou a atenção foi  o uso de uma avião capaz de confundir as defesas inimigas, e mais ainda, a possibilidade de infectar computadores inimigos com virus. 

Só fico pensando no software embarcado neste avião (rs). 

Tudo isso me faz lembrar cenas de ficção cientifica onde campos de força, torpedos fotonicos, armas de raios laser, sabres de luz, e outras tractanas tecnológicas são comuns. 

Será que chegaremos a esse ponto???   leia o texto e tire suas próprias conclusões:

Os Estados Unidos utilizam na ação militar na Líbia a aeronave de "guerra eletrônica" EA-18G Growler, que tem a capacidade de embaralhar as comunicações do inimigo. Serve, por exemplo, para evitar que as defesas antiaéreas da Líbia localizem e derrubem os caças da coalizão composta por EUA, França, Reino Unido e outros países.

Segundo reportagem do site da revista "Aviation Week", especializada em aviação, a operação na Líbia "marca a estreia em combate do EA-18G", que foi recém-incorporado à frota da Marinha dos EUA, em substituição aos EA-6B, em serviço desde 1971.

O avião é uma das apostas dos EUA para evitar perdas de aeronaves em combate. Desde o início dos ataques na Líbia, no sábado (19), apenas um avião da coalizão caiu. Foi um caça F-15, na madrugada desta terça (22) - segundo o governo americano, por problemas mecânicos.

Um porta-voz do Pentágono disse, em entrevista no domingo (20), que os EA-18G foram usados no fim de semana para apoiar um ataque de 15 aviões da coalizão contra forças de Kadhafi que estavam a cerca de 15 km de Benghazi, a principal cidade rebelde. Segundo o porta-voz, esse ataque parou a marcha das tropas de Kadhafi em direção a Benghazi.

A função da aeronave é realizar interferência eletrônica de dispositivos e sistemas eletrônicos – ou "enganar" os radares inimigos. Ela consegue também atrapalhar ataques antiaéreos inimigos. Segundo reportagem da revista Wired, uma futura geração do EA-18G será capaz de introduzir vírus em redes de computador dos países atacados.

Apesar de não conhecer as características específicas do EA-18G Growler, o professor de telecomunicações da Poli-USP Luiz Baccalá explica como funcionam as assim chamadas “contramedidas eletrônicas”. Ele afirma que se trata de uma tecnologia de “processamento de sinais”.

“Qualquer radar de defesa manda pulsos, que batem em um alvo qualquer e, a partir disso, é possível deduzir algumas informações sobre esse alvo, como distância e velocidade”, explica. Uma interferência pode fazer com que as informações sejam entendidas de maneira diferente. “Acaba havendo uma indução do inimigo de entender aquele sinal como se estivesse em uma velocidade diferente, por exemplo”, completa.

Fonte: g1.com

Banco de dados com NHibernate

Quando se fala em orientação a objetos e desenvolvimento multi-camadas uma das coisas que mais "pegam" é a camada de persistência, quanto pensamos em desenvolver algo que seja portável para diversos bancos de dados diferentes (Ex. Firebird, MS-SQL, Oracle, Etc). 

Existem diversas alternativas para solucionar esse problema, deste você mesmo construir suas classes de persistência, ou utilizar um dos diversos frame-works existentes. 

Um desses frameworks que tem sido usado largamente pela plataforma Java e também .NET é o Hibernate, que na versão .NET torna-se NHibernate.

Então vamos lá aprender um pouco mais sobre o assunto: 

NHibernate é uma das soluções de Mapeamento objeto-relacional (ORM) para a plataforma de desenvolvimento Microsoft .NET, um framework que fornece o mapeamento do modelo relacional para a orientação a objeto.

O NHibernate é livre e de código aberto e é a versão portada do Java para o Microsoft .NET do Hibernate.

Ele lida com plano de persistência para objetos e de um subjacentes de dados relacionais. Dando uma descrição XML de suas entidades e relacionamentos, NHibernate gera automaticamente códigos SQL para carregar e guardar os objectos. Opcionalmente, você pode descrever o seu mapeamento de metadados com atributos em seu código fonte.

Suporta persistência transparente, o seu objeto classes não têm de seguir um modelo de programação restritiva. Classes persistentes não precisam implementar nenhuma interface ou herdar de uma classe especial base. Isto torna possível desenvolver a lógica empresarial utilizando o plano de objetos .NET (CLR) e Orientação a Objetos.

Originalmente sendo uma parte do Hibernate 2.1, o NHibernate API é muito semelhante ao do Hibernate. Todo o conhecimento e documentação existente é, portanto, diretamente aplicável ao NHibernate. 

Neste link você encontra uma lista do Dialetos SQL Suportados Pelo Hibernate:

List of Hibernate SQL Dialects

Fontes :

Wikipédia 

JavaBeat

Um Falso Amigo

Você tem um "amigo" que conheceu quando não sabia programar. Ele fazia você se sentir mais maduro e parecia ajudá-lo a ser aceito pelos programadores. Quando você ficava estressado, sempre podia encontrar certa medida de "alívio" com ele. De fato, você passou a depender dele em muitas situações.

Mas, com o tempo, você descobriu o lado sombrio desse amigo. Ele exige sua companhia o tempo todo e, por causa dele, você não é bem vindo em alguns lugares. E, embora ele talvez tenha feito você se sentir mais maduro, isso se deu à custa de sua falta de experiência. Para completar, ele rouba parte do seu salário.

Ultimamente, você tentou várias vezes acabar com essa amizade, mas ele não deixou. De certa forma, você se tornou escravo dele. Você gostaria de nunca tê-lo conhecido. 

Esse amigo se chama Gambiarra.

Fluxograma para testar a Gambiarra.

Definição de Gambiarra

No sentido de improviso ou improvisação, gambiarra é o próprio ato de constituir uma solução improvisada. 

A Questão Etimológica

Segundo o dicionário Aurélio, gambiarra quer dizer “Lâmpada instalada na extremidade dum comprido cabo elétrico para poder ser utilizada numa área relativamente grande”. Entretanto, no mundo da programação de computadores, gambiarra quer dizer algo feito de improviso que quase sempre dá errado! 

Segundo o dicionário Hoauiss (2001), o termo gambiarra tem etimologia de origem "contraditória e duvidosa". Nos principais dicionários brasileiros, a primeira acepção para o termo gambiarra é "uma ramificação ou extensão de luzes". Apesar do evidente e difundido uso informal do termo no Brasil, visto como uma forma de "improvisação", nenhum destes dicionários inclui qualquer acepção que se refira precisamente a este significado.

Gambiarra em Outros Segmentos

O termo é utilizado em diversas áreas profissionais como informática, programação, eletrônica, engenharia civil, cinema, teatro, artes plásticas, arquitetura, design, geralmente se referindo a soluções improvisadas, adaptações, ajustes, muitas vezes como uma solução que não se utiliza de métodos, plano ou projeto. A gambiarra é muitas vezes entendida de forma pejorativa como algo em condições precárias, provisório, transitório, mal-acabado ou rústico.

Apesar de todas as situações que tendem a forçar o uso de uma gambiarra para a solução rápida de um problema, é preciso que nos esforcemos  ao máximo para não utilizar este expediente. Estude, pesquise e utilize as ferramentas certas ... com certeza as soluções encontradas sem gambiarras permanecem. 

  

Introdução ao C# (CSharp)

Com esse artigo inicio uma série sobre esta linguagem de programação.
C# (pronuncia-se "cê chárp" em português ou "cí charp" em inglês), é uma linguagem de programação orientada a objetos, fortemente tipada, desenvolvida pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a objetos foi baseada no C++ mas inclui muitas influências de outras linguagens de programação, como Object Pascal e Java.

A criação da linguagem, embora tenha sido feita por vários programadores, é atribuída principalmente a Anders Hejlsberg, hoje um Distinguished Engineer na Microsoft. Ele fora o arquiteto de alguns compiladores da Borland, e entre suas criações mais conhecidas estão o Turbo Pascal e o Delphi.

Características

O C# é, de certa forma, a linguagem de programação que mais diretamente reflete a plataforma .NET sobre a qual todos os programas .NET executam. C# está de tal forma ligado a esta plataforma que não existe o conceito de código não-gerenciado (unmanaged code) em C#. Suas estruturas de dados primitivas são objetos que correspondem a tipos em .NET. A desalocação automática de memória por garbage colletor além de várias de suas abstrações tais como classes, interfaces, delegados e exceções são nada mais que a exposição explicita recursos do ambiente .NET.

Quando comparada com C e C++, a linguagem é restrita e melhorada de várias formas incluindo:

* Ponteiros e aritmética sem checagem só podem ser utilizados em uma modalidade especial chamada modo inseguro (unsafe mode). Normalmente os acessos a objetos são realizados através de referências seguras, as quais não podem ser invalidadas e normalmente as operações aritméticas são checadas contra sobrecarga (overflow).

* Objetos não são liberados explicitamente, mas através de um processo de coleta de lixo (garbage collector) quando não há referências aos mesmos, previnindo assim referências inválidas.

* Destrutores não existem. O equivalente mais próximo é a interface Disposable, que juntamente com a construção using block permitem que recursos alocados por um objeto sejam liberados prontamente. Também existem finalizadores, mas como em Java sua execução não é imediata.

* Como no Java, não é permitida herança múltipla, mas uma classe pode implementar várias interfaces abstratas. O objetivo principal é simplificar a implementação do ambiente de execução.

* C# é mais seguro com tipos que C++. As únicas conversões implícitas por default são conversões seguras, tais como ampliação de inteiros e conversões de um tipo derivado para um tipo base. Não existem conversões implícitas entre inteiros e variáveis lógicas ou enumerações. Não existem ponteiros nulos (void pointers) (apesar de referências para Object serem parecidas). E qualquer conversão implícita definida pelo usuário deve ser marcada explicitamente, diferentemente dos construtores de cópia de C++.

* A sintaxe para a declaração de vetores é diferente ("int[] a = new int[5]" ao invés de "int a[5]").

* Membros de enumeração são colocados em seu próprio espaço de nomes (namespace)

* C# não possui modelos (templates), mas C# 2.0 possui genéricos (generics).

* Propriedades estão disponíveis, as quais permitem que métodos sejam chamados com a mesma sintaxe de acesso a membros de dados.

* Recursos de reflexão completos estão disponíveis

C# Versus Java 

Apesar de C# ser freqüentemente tido como similar a Java, existem uma série de diferenças importantes, tais como:

* Java não implementa propriedades nem sobrecarga de operadores.

* Java não implementa um modo inseguro que permita a manipulação de ponteiros e aritmética sem checagem.

* Java possui exceções checadas, enquanto exceções em C# são não checadas como em C++.

* Java não implementa o goto como estrutura de controle, mas C# sim.

* Java utiliza-se de comentários Javadoc para gerar documentação automática a partir de arquivos fonte. C# utiliza comentários baseados em XML para este propósito.

* C# suporta indexadores e delegados.

Bibliotecas de códigos

Ao contrário das outras linguagens de programação, nenhuma implementação de C# atualmente inclui qualquer conjunto de bibliotecas de classes ou funções. Ao invés disso, C# está muito vinculada ao framework .Net, do qual C# obtém suas classes ou funções de execução. O código é organizado em um conjunto de namespaces que agrupam as classes com funções similares. Por exemplo: System.Drawing para gráficos, System.Collections para estrutura de dados e System.Windows.Forms para o sistema Windows Form.

Um nível de organização superior é fornecido pelo conceito de montador (assembly). Um montador pode ser um simples arquivo ou multiplos arquivos ligados juntos (como em al.exe) que podem conter muitos namespaces ou objetos. Programas que precisam de classes para realizar uma função em particular podem se referenciar a montadores como System.Drawing.dll e System.Windows.Forms.dll assim como a biblioteca core (conhecida como mscorlib.dll na implementação da Microsoft).

Para quem desejar saber mais sobre o assunto seguem alguns links que entre outros serviram de base para este post

wikipedia e Oficina da Net 

O Silverlight morreu?

Na manhã de hoje (23/11/2010), em uma reunião com a equipe de desenvolvimento da empresa onde trabalho, um dos colaboradores afirmou categoricamente: "o Silverlight morreu, foi descontinuado pela Microsoft" ....

A informação de que o Silverlight estaria morto acabou gerando em mim uma curiosidade sobre o fato. Então fui em busca de informações sobre o assunto, pois participei ao longo dos últimos tempos de diversos eventos oficiais da Microsoft onde muito se falou sobre esse produto, e pareceu-me incoerente descontinua-lo.

Pesquisei a Internet e realmente existe uma tendência de que funcionalidades existentes no Silverlight sejam incorporadas pelo HTML5 e isso é admitido pela propria Microsoft.

Porém está longe de dizer-se que ele esteja morto ... tanto que a Microsoft divulgou no seu site de carreiras, vagas para contratação de engenheiros para o Silverlight. Se o "cara" está morto? porque contratar novos engenheiros para manter e evoluir o "defunto"?

http://www.baboo.com.br/conteudo/modelos/Silverlight-no-Xbox_a40445_z345.aspx

Também parece-me estranho que o EcoDevelopers, um evento em parceria com a Comtec, Sebrae e Microsoft que acontece amanhã (24/11/2010), aqui em Goiânia,   tenha em sua agenda uma palestra falando sobre um produto que já teria sido descontinuado.  

http://www.ecodevelopers.net/Goiania/Agenda

A pouco mais de 15 dias alguns amigos meus fizeram prova para certificação Microsoft em Silverlight.

Estas são apenas algumas considerações que faço sobre o assunto, sem o interesse de radicalizar ou trazer polêmica, nem mesmo iniciar uma infrutífera discução sobre o tema, afinal de contas, o tempo é quem vai responder a esta questão .... morreu ou não morreu? 

A Microsoft realizará um evento sobre o Silverlight no próximo dia 3 de dezembro. Nele a empresa deverá detalhar seus futuros planos para a tecnologia.

Como desenvolvedor Delphi, a muito ouço dizer que o Delphi é uma linguagem morta, e o tempo tem mostrado que a história não é bem essa !.

Abraços, e até o proximo post. 

Interface Gráfica do GIT

Olá amigos ... 

Aqueles que me acompanham sabem que sou fã incodicional do GIT e o considero como um dos melhores softwares de SCM (source code management) da atualidade. Entretanto alguns amigos sempre reclamavam de usa-lo via linha de comando ( particularmente eu gosto. Linha de comando te dá segurança e controle total da situação). 

Para esses meu amigos, vai a dica deste post: usar o comando git gui : O gui vem de graphics user interface ou seja interface gráfica com o usuário. Nesta interface você pode realizar o add + commits + push + um montão de comandos do git, tudo de forma gráfica. Eu mesmo uso bastante esse recurso. 

Quando se abre a tela no canto superior direito aparece o quadro chamado de Unstaged changes onde são mostrados os itens do repositorio que foram alterados/criados e que ainda não foram adicionados ao indice do git. Para adiciona-los ao indice basta clicar no ícone do item, o que equivale a linha de comando "git add nome_do_arquivo".  

Logo abaixo temos o quadro de Staged changes (will commit) . nesse quadro aparecem os itens que foram adicionados ao indice, porém ainda não foram commitados. Para retornar um item desse quadro para o quadro Unstaged Changes, apenas clique no seu ícone. 

Digite o texto do seu commit no quadro Commit Message e clique no botão Commit. Pronto isso equivale à linha de comando "git commit -m "mensagem do commit" " . 

Em seguida se quiser "empurrar" suas alterações para o servidor, basta clicar no botão push .

Além disso você poderá selecionar um arquivo e reverter as mudanças, deletar aquivos, gerenciar branches e muito mais através dessa ferramenta nativa do git. 

Se você ficou curioso, dê uma olhada nos menus desta ferramenta e veja as inúmeras possibilidades que ela oferece. 

No meu proximo post vou falar de outra ferramenta gráfica para trabalhar com o git ... a versão do Tortoise para o GIT ... 

Um grande abraço e até o próximo post. 

Você conhece Objective-C

Um post do Adriano Santos no seu blog Delphi To Delphi  chamou minha atenção, sobre uma fatia do mercado que percebo como pouco explorada atualmente no Brasil, os aplicativos para iPhone, iPad e iPod.

Procurando um pouco mais de informação sobre o assunto, deparei-me com a linguagem Objective-C, que para quem não sabe é a linguagem usada para criação de aplicações para os sistemas da Apple.

Um pouco de história 

O ObjC foi criado principalmente por Brad Cox e Tom Love no início da década de 1980 na empresa deles, a Stepstone. A principal descrição do Objective-C em sua forma original foi publicada no livro de Cox, Object-Oriented Programming, An Evolutionary Approach, de 1986.

Em 1988, a NeXT de Steve Jobs licenciou o Objective-C da StepStone (a dona da marca registrada Objective-C) e liberou sua própria versão do compilador e das bibliotecas da linguagem nas quais a interface do usuário e da estrutura NeXTstep eram baseadas. O sucesso das ferramentas e a qualidade do sistema operacional resultante ajudaram a NeXT a ocupar um nicho de provedor de workstations bastante popular.

O projeto GNU começou a trabalhar em seu clone livre do NeXTStep baseado no padrão OpenStep, o GNUstep. Dennis Glatting escreveu o primeiro runtime do gnu-objc em 1992, e Richard Stallman criou o segundo pouco depois. O runtime do GNU Objective-C que tem estado em uso desde 1993 é aquele desenvolvido por Kresten Krab Thorup, quando ele era estudante universitário na Dinamarca. Kresten também trabalhou para a NeXT por algum tempo.

Depois de adquirir a NeXT em 1996, a Apple usou o OPENSTEP como base para seu principal sistema operativo, o Mac OS X. Isto inclui o Objective-C e a ferramenta de desenvolvimento NeXT's Objective-C, o Project Builder (mais tarde substituído pelo Xcode), bem como sua ferramenta de projeto de interface, Interface Builder.

A maior parte da presente API Cocoa da Apple está baseada na interface de objetos OpenStep, e este é o mais significativo ambiente Objective-C sendo usado para desenvolvimento ativo.

O Objective-C é uma camada construída sobre a linguagem C e constitui-se num superconjunto estrito de C. Ou seja, é possível compilar qualquer programa C com um compilador Objective-C. O Objective-C deriva sua sintaxe tanto do C quanto do Smalltalk. A maior parte de sua sintaxe (incluindo pré-processamento, expressões, declaração e chamadas de funções) foi herdade do C, enquanto a sintaxe para os aspectos orientados a objetos foi criada para habilitar passagem de mensagens no estilo Smalltalk.

Ambiente de programação

Para programar em Objective-C, tal como em qualquer outra linguagem moderna, você precisa de um editor e um compilador. Ambos estão disponíveis gratuitamente em muitos dos sistemas operacionais atuais.

No MacOS X, você deve instalar os "Developer Tools" gratuitos da Apple, caso eles não estejam presentes no seu sistema. Essas ferramentas incluem dentre muitas outras coisas o compilador gcc e um ambiente de programação extremamente eficiente, denominado Xcode.

No Linux você já deve ter o gcc instalado, bem como muitos editores de texto (vi, pico, emacs). Você tambem pode utilizar algum ambiente de programação, como o KDevelop ou ferramentas GNUStep.

No Windows você pode instalar o compilador Objective-C que acompanha o sistema MinGW (http://www.mingw.org). Para escrever os códigos, qualquer editor de texto puro, como o Notepad, ou algum ambiente de programação devem servir.

Nos três sistemas, compilar um programa utilizando a linha de comando resume-se ao gcc (para projetos maiores costuma-se utilizar ferramentas como make, automake, etc), cujo formato geral de chamada é:

Portanto, chegamos a conclusão que por ser uma linguagem derivada do C, quem já possui algum conhecimento sobre esta linguagem larga na frente. 

Com o crescimento das vendas dos equipamentos da Apple no mercado brasileiro, creio que seja uma possibilidade a ser observada com carinho. 

Um agrande abraço e sucesso ao Adriano Santos o mais novo licenciado como desenvolvedor Apple®.

Fontes utilizadas neste post: 

http://pt.wikipedia.org/wiki/Objective-C

http://www.astro.iag.usp.br/~algol/computacao/ObjCtutorial.html

Número por Extenso

Diante da necessidade de gerar valores por extenso, pesquisando na web, deparei-me com a excelente procedure abaixo, para Firebird. 

Ela não usa UDF´s e consegue gerar extenso para valores de até 8 (oito) quatrilhões.

Ela pode ignorar a geração do extenso dos centavos, para o caso de um extenso para cheques (basta atribuir 'N' ao segundo parâmetro).
 
Parabéns ao Emersom, o autor dessa "belezura" !!!

CREATE PROCEDURE EXTENSO (
    valor numeric(18,2),
    cents char(1))
returns (
    valorextenso varchar(250))
as
declare variable cmoeda varchar(10);
declare variable cmoedas varchar(10);
declare variable ccentavo varchar(10);
declare variable ccentavos varchar(10);
declare variable cmil varchar(12);
declare variable cmils varchar(12);
declare variable cmilhao varchar(12);
declare variable cmilhoes varchar(12);
declare variable cbilhao varchar(12);
declare variable cbilhoes varchar(12);
declare variable ctrilhao varchar(12);
declare variable ctrilhoes varchar(12);
declare variable cquatrilhao varchar(12);
declare variable cquatrilhoes varchar(12);
declare variable cvalor varchar(100);
declare variable nvalor smallint;
declare variable cvalorint varchar(100);
declare variable nvalorint integer;
declare variable nvalordec  numeric(6,3);
declare variable i smallint;
declare variable nconj integer;
declare variable cletra varchar(1);
declare variable caux varchar(200);
declare variable extensocentavos varchar(100);
declare variable separador varchar(3);
declare variable extensoconj varchar(150);
declare variable cdig1 varchar(10);
declare variable cdig2 varchar(10);
declare variable cdig3 varchar(10);
declare variable centenas char(108) = 'CENTO       DUZENTOS    TREZENTOS   QUATROCENTOSQUINHENTOS  SEISCENTOS  SETECENTOS  OITOCENTOS  NOVECENTOS  ';
declare variable dezenas char(79) = 'DEZ      VINTE    TRINTA   QUARENTA CINQUENTASESSENTA SETENTA  OITENTA  NOVENTA  ';
declare variable unidades char(54) = 'UM    DOIS  TRES  QUATROCINCO SEIS  SETE  OITO  NOVE  ';
declare variable unid10 char(81) = 'ONZE     DOZE     TREZE    QUATORZE QUINZE   DEZESSEISDEZESSETEDEZOITO  DEZENOVE ';
declare variable extensounidade varchar(12);
declare variable extensodezena varchar(12);
declare variable extensocentena varchar(12);
declare variable vlrextenso varchar(250);
begin
  if (cents is null) then cents = 'S';
  cents = UPPER(cents);
 
  -- poderia ter deixado esses valores fixos,
  -- mas preferi em variáveis
  cMil = 'MIL'; cMils = 'MIL';
  cMilhao = 'MILHÃO'; cMilhoes = 'MILHÕES';
  cBilhao = 'BILHÃO'; cBilhoes = 'BILHÕES';
  cTrilhao = 'TRILHÃO'; cTrilhoes = 'TRILHÕES';
  cQuatrilhao = 'QUATRILHÃO'; cQuatrilhoes = 'QUATRILHÕES';
  cMoeda = 'REAL'; cMoedas = 'REAIS';
  cCentavo = 'CENTAVO'; cCentavos = 'CENTAVOS';
  Separador = ' ';
 
  -- valores a serem utilizados para geração do extenso
  nValorInt = cast(valor/100*100 as integer);
  nValorDec = (Valor - Cast(nValorInt as numeric(18,3))) / 10;
  cAux = Cast(nValorDec as varchar(100));

  cValorInt = Cast(nValorInt as varchar(100)) || Substring(cAux from 3 for 3);
 
  -- inverto o número. assim fica mais fácil trabalhar
  -- pois não haverá necessidade de UDF's
  cLetra = Substring(cValorInt from 1 for 1);
  cAux = cValorInt;
  cValorInt = '';
  while (cAux <> '') do
  begin
    cValorInt = (cLetra || cValorInt);
    cAux = Substring(cAux from 2 for 100);
    cLetra = Substring(cAux from 1 for 1);
    if (cLetra = '') then cLetra = ' ';
  end
 
  -- obtenho os subconjuntos de números, de 3 em 3,
  -- para formar o extenso, que poderá chegar aos quatrilhões
  nConj = 1;
  extensocentavos = '';
  vlrextenso = '';
 
  if (Valor <> 0) then
  begin
    while (cValorInt <> '') do
    begin
      cValor = '';
      i = 1;
      while (i <= 3) do
      begin
        cLetra = Substring(cValorInt from 1 for 1);
        if (cLetra = '') then cLetra = ' ';
        cValor = (cLetra || cValor);
        cValorInt = Substring(cValorInt from 2 for 100);
        i = (i + 1);
      end
 
      nValor = Cast(cValor as smallint);
 
      cDig1 = Substring(cValor from 1 for 1);
      cDig2 = Substring(cValor from 2 for 1);
      cDig3 = Substring(cValor from 3 for 1);
 
      extensounidade = '';
      extensodezena = '';
      extensocentena = '';
 
      -- obtenho o extenso da unidade
      if (cDig3 > '0') then
      begin
        cAux = cast((cast(cDig3 as integer) * 6 - 5) as varchar(3));
        cAux = 'select cast(Substring(''' || unidades || ''' from ' || cAux || ' for 6) as varchar(12)) from rdb$database';
        execute statement cAux into :extensounidade;
      end
 
      -- obtenho o extenso da dezena
      if (cDig2 > '0') then
      begin
        if ((cDig3 > '0') and (cDig2 = '1')) then
        begin
          extensounidade = '';
          cAux = unid10 || ''' from ' || cast((cast(cDig3 as integer) * 9 - 8) as varchar(3));
        end
        else
          cAux = dezenas || ''' from ' || cast((cast(cDig2 as integer) * 9 - 8) as varchar(3));
        cAux = 'select cast(Substring(''' || cAux || ' for 9) as varchar(12)) from rdb$database';
        execute statement cAux into :extensodezena;
      end
 
      -- obtenho o extenso da centena
      if (cDig1 > '0') then
      begin
        if (nValor = 100) then
          extensocentena = 'CEM';
        else
        begin
          cAux = cast((cast(cDig1 as integer) * 12 - 11) as varchar(3));
          cAux = 'select cast(Substring(''' || centenas || ''' from ' || cAux || ' for 12) as varchar(12)) from rdb$database';
          execute statement cAux into :extensocentena;
        end
      end
 
      -- faço a montagem do extenso do conjunto
      if (extensounidade <> '') then
        extensoconj = extensounidade;
      else
        extensoconj = '';
 
      if (extensodezena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensodezena || ' E ' || extensoconj;
        else
          extensoconj = extensodezena;
      end
 
      if (extensocentena <> '') then
      begin
        if (extensoconj <> '') then
          extensoconj = extensocentena || ' E ' || extensoconj;
        else
          extensoconj = extensocentena;
      end
 
      -- adiciono os devidos sufixos de cada conjunto
      if (nValor > 0) then
      begin
        if (nConj = 1) then -- centavos
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' ||ccentavos;
          else
            extensoconj = extensoconj || ' ' || ccentavo;
        end
 
        -- obs.: o conjunto 2 não precisa ser avaliado, pois
        --       nele NÃO há necessidade de acrescentar sufixo
 
        if (nConj = 3) then -- milhares
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMils;
          else
            extensoconj = extensoconj || ' ' || cMil;
        end
        else
        if (nConj = 4) then -- milhoes
        begin
        if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cMilhoes;
          else
            extensoconj = extensoconj || ' ' || cMilhao;
        end
        else
        if (nConj = 5) then -- bilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cBilhoes;
          else
            extensoconj = extensoconj || ' ' || cBilhao;
        end
        else
        if (nConj = 6) then -- trilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cTrilhoes;
          else
            extensoconj = extensoconj || ' ' || cTrilhao;
        end
        else
        if (nConj = 7) then -- quatrilhoes
        begin
          if (nValor > 1) then
            extensoconj = extensoconj || ' ' || cQuatrilhoes;
          else
            extensoconj = extensoconj || ' ' || cQuatrilhao;
        end
 
        if ((vlrextenso = '') and (nConj > 3)) then
          extensoconj = extensoconj || ' DE ';
      end
 
      -- avalio qual será o separador de conjuntos
      if (nConj < 4) then
        Separador = ' E ';
      else
        Separador = ', ';
 
      -- gero o extenso dos 'inteiros' e dos centavos
      if (nConj = 1) then -- centavos
        extensocentavos = extensoconj;
      else
      if (extensoconj <> '') then
      begin
        if (vlrextenso <> '') then
          vlrextenso = extensoconj || Separador || vlrextenso;
        else
          vlrextenso = extensoconj;
      end
 
      nConj = nConj + 1;
    end
 
    -- depois de tudo avaliado...
    -- acrescento a moeda
    if (nvalorint > 0) then
    begin
      if (nvalorint > 1) then
        vlrextenso = vlrextenso || ' ' || cmoedas;
      else
        vlrextenso = vlrextenso || ' ' || cmoeda;
    end
 
    -- monto o extenso completo: inteiros mais os centavos.
    -- obs.: a inclusão dos centavos é controlada pela variável
    -- 'cents'. fiz assim pois pode ser uma geração de extenso
    -- para cheques, que não destacam os centavos no extenso
    if ((extensocentavos <> '') and (cents = 'S')) then
    begin
      if (vlrextenso <> '') then
        vlrextenso = vlrextenso || ' E ' || extensocentavos;
      else
        vlrextenso = extensocentavos;
    end
  
    -- limpo a variavel de retorno, pois ainda preciso trabalhar os 'espaços'
    valorextenso = '';
 
    -- retiro os espacos desnecessários e populo a variável de retorno.
    -- obs.: fiz com while pra não precisar de UDF's
    cLetra = Substring(vlrextenso from 1 for 1);
    cAux = '';
    while (vlrextenso <> '') do
    begin
      cLetra = Substring(vlrextenso from 1 for 1);
      vlrextenso = Substring(vlrextenso from 2 for 250);
      if ((cLetra <> ' ') or ((cLetra = ' ') and (cAux <> ' ')))  then
        valorextenso = valorextenso || cLetra;
      cAux = cLetra;
    end
  end
  else
    valorextenso = 'ZERO';
 
  -- exibe o resultado
  suspend;
end

-----

Veja o Post Original em http://www.firebase.com.br/fb/artigo.php?id=2078

Firebird - Comandos SQL úteis - Substring, Cast, Case, Like

Olá amigos esse post abaixo é um copy / paste que fiz do endereço no final do post .... quero agradecer ao Thunder Boy pelas dicas ... não deixem de dar uma passada lá no blog dele e conferir. 

Problema: Como mostrar apenas parte dos dados de um coluna em um relatório?

=============================
SUBSTRING
=============================
Conheça o  “substring”, mas como ele funciona? 

A sintaxie é a seguinte: select substring (”nome do campo” from “coluna_inicial” for “caracteres”) from “nome da tabela”

Exemplo: A máscara de estoque é de 8 digitos, porém quero que na SQL mostre apenas os 3 últimos dígitos

select substring (codpa from 6 for 3) as Referencia from etprocab where codemp=1

Nota: Este comando é muito útil e pode ser usado inclusive para acerto de base, quando é necessário diminuir o tamanho de alguma configuração, para isto basta combiná-lo com update

=============================
CAST
=============================

Porém a coluna irá ser mostrada grande, devido ao tamanho que foi criada, ai neste caso basta usar o “cast” para reduzir o tamanho da coluna na consulta

Exemplo:

select cast(substring (codpa from 6 for 3) as varchar (3)) as Ref from etprocab
where codemp=1

Nota: Este comando é útil, para ser usado no gerrel, pois neste caso iria mostrar a coluna grande no excel e após usar o “cast” o tamanho da coluna fica limitada ao tamanho informado no comando

=============================
LIKE
=============================

Outro comando bacana é o like, que acredito que não seja novidade pra ninguém, porém mesmo assim vai a dica:

select * from dtclifor
where insestrg like ‘%NTO’ /* Neste caso o percentual antes da palavra substitui as letras que o antecede */
and insestrg like ‘ISE%’ /* Neste caso o percentual depois da palavra substitui as letras da sequencia */
and insestrg like ‘%EN%’ /* E entre percentuais ira retornar todos valores que contenham a consulta em qualquer parte do campo */

Mais se quiser consultar todos os registros que variam apenas um caracter, como faço?

Basta utilizar o “_” (underline) no lugar do percentual, pois neste caso ele irá considerar a variação de apenas uma casa decimal na consulta.

Exemplo:

select * from dtclifor
where codclifor like ‘10000_1′

=============================
CASE
=============================

E vai a dica do comando case, onde com ele é possivel mostrar dados que seriam mostrados por linha, nas colunas

Exemplo:

select
sum ( case when vendedor = 1 then pretot else 0 end ) as Vendedor_1,
sum ( case when vendedor = 2 then pretot else 0 end ) as Vendedor_2,
sum ( case when vendedor = 3 then pretot else 0 end ) as Vendedor_3,
sum ( case when vendedor = 4 then pretot else 0 end ) as Vendedor_4
from vtvencor
where tipo in (’VBA’, ‘VBT’, ‘VCO’)
and situacao=1
and codemp=1

Nota: Este é um exemplo simples de como usar o comando case, onde mostra o valor vendido com base na tabela vtvencor, porém não é considerado os descontos e acréscimos do cadastro da venda e mostra os valores independente da venda cadastrada ou não. É apenas para demonstrar o uso do case.

=============================
COMENTÁRIO EM COMANDOS
=============================

Outra dica útil é poder colocar comentários em comandos para isso basta entre os comentários colocar as tags “/*” para iniciar e “*/” para finalizar, com isso ao executar o comando, não será considerado o que estiver entre as tags

Exemplo:

select * from dtclifor
where codemp=1 /* Comentário qualquer de sua preferencia… */

Este post foi Copiado deste link http://infoblogs.com.br/frame/goframe.action?contentId=41528

Compilar em apenas um passo

Na serie de arigos sobre o teste do Joel estou escrevendo sobre os pontos que devem ser levados em consideração para a melhor o processo de produção de software.

A segunda  pergunta do teste do Joel é saber se você pode compilar todo o projeto em apenas um passo. Essa é uma questão essencial e um desafio para muitas equipes. Em muitos casos perdem-se horas sagradas para gerar um novo Release.

Boas equipes possuem um único script que faz um checkout completo do zero, reconstrói cada linha de código, faz os EXE's, em todas as suas várias versões, linguagens e combinações de #ifdef, cria o pacote de instalação e cria a mídia final -- layout do CDROM, download do website, o que seja.

Se este processo possui mais de uma etapa, ele tende a ter erros. E quanto mais perto você chega da data de entrega, mais você quer ter um ciclo realmente rápido para corrigir o "último" bug, fazer os EXE's finais, etc. Se você leva 20 etapas para compilar o código, executar o construtor de instalação, etc, você vai enlouquecer e cometerá erros bobos.

Para automatizar o processo de compilação existem diversas ferramentas mas duas premissas sempre se mantêm independente da ferramenta escolhida :

• Deve ser possível compilar o projeto inteiro em um passo
• Deve ser possível usar qualquer máquina de desenvolvimento para isso

Citando algumas ferramentas:

Cruise Control  - ferramenta que automatiza o processo de build, provendo várias tarefas que facilitam o controle sobre o código, incluindo uma interface para visualizar os detalhes sobre cada build

Visual Build Professional -   ferramenta que possui suporte para o Microsoft Visual Studio .NET/2005, Visual Studio Team System, Visual Basic, Visual C++, SourceSafe, eMbedded Tools, Borland Developer Studio, Delphi, JBuilder, C++Builder, ClearCase.  Para sistemas de builds pequenos/medios ele é excelente. Já para builds de grande porte, pode não ser uma boa já que ele não permite o que, em alguns casos, dificulta o reaproveitamento dos scripts.

Além das ferramentas acima ainda merecem ser lembradas o Quick Build e o Luntbuild

Finalizando ...

Seja qual for a sua ferramenta preferida, o que realmente importa é que o processo seja o mais automatizado possivel, para assim diminuir as possibilidades de erros, como também agilizar o processo de deploy de novas versões do sistema.

Para quem desejar saber mais sobre o assunto seguem alguns links que entre outros serviram de base para este post

http://josepaulopapo.blogspot.com/2006/02/integrao-contnua-e-gesto-de-builds-com.html

http://www.caloni.com.br/blog/archives/como-compilar-em-somente-um-passo

http://brazil.joelonsoftware.com/Articles/TheJoelTest.html

O Planning Poker

Antes de mais nada o conceito

O Planning Poker é uma técnica de estimativa baseada no consenso de toda a equipe, onde é utilizado um conjunto de cartas com valores específicos que podem representar pontos relativos ou até mesmo horas (esses valores podem seguir a seqüência de fibonacci) e é praticado como se fosse um jogo. Uma pessoa apresenta a tarefa ou estória para o time, e, após uma breve discussão, cada um escolhe uma carta e coloca virada para baixo sobre uma mesa. Quando todas as cartas estiverem lançadas, elas são viradas e caso não haja consenso nos valores escolhidos, as diferenças são discutidas de forma breve, e uma nova rodada acontece até que haja a convergência.

Porque usar o Planning Poker?

Quem trabalha com desenvolvimento de software sabe que um dos nossos maiores desafios é conseguir mensurar o tamanho de cada tarefa com uma boa precisão, e, conseqüentemente, conseguir prever quando determinado recurso deverá ser concluído. A forma como fazemos nossas estimativas tem um grande impacto na confiabilidade de nossos prazos, porém, nem sempre as equipes tomam consciência desse fato, e continuam dando pouco valor ou dedicando menos esforço do que deveriam a essa atividade.

Seja qual for a metodologia de trabalho que sua equipe utiliza (scrum + XP ou outra mais tradicional) você pode utilizar diversas técnicas de estimativas. 

Algumas vantagens do Planning Poker:

· Equipe mais comprometida, pois todos participam;

· Força a equipe a ter um conhecimento de negócio mais homogêneo;

· Aumenta bastante a precisão das estimativas, pois considera a experiência de todos;

· Mais atraente (divertida) que as demais técnicas.

Se seu time está tentando implementar o scrum, algumas considerações:

· Estórias são funcionalidades, na forma como tem valor para o cliente (no scrum, o PO ou Product Owner). Exemplo: Eu como usuário quero poder cadastrar um produto;

· Tarefas são as implementações que devem ser feitas para que a funcionalidade seja entregue. Uma estória pode possuir uma ou mais tarefas;

· Nós só conseguimos estimar com precisão as tarefas pequenas. Se estiver estimando em horas, um valor maior que oito já é considerado um ‘chute’, e geralmente significa que aquela tarefa deve ser particionada em pelo menos duas partes, e reestimada, portanto, é recomendável assumir que cada tarefa deve ser pequena o suficiente para poder ser executada em um dia;

· Nem todas as estórias precisam ser detalhadas durante as estimativas. Se você trabalha com scrum, durante o backlog estimate (reunião, geralmente semanal, onde estimamos apenas as estórias de usuário) todas as estórias são reestimadas, e as estórias grandes são quebradas de acordo com a priorização do Product Owner. Dessa forma, as estórias com prioridade mais baixas podem ser estimadas com valores mais altos, e seu detalhamento pode ser postergado para quando se tornarem mais próximas de serem selecionadas para o sprint;

· Estimativas por horas devem ser feitas sem considerar as interrupções, ou seja, o tempo que efetivamente levaríamos para concluir a tarefa em um dia ideal;

· Estimativas por pontos é uma técnica muito boa para se estimar as estórias de usuário e não as tarefas, que usamos estimativas por horas em dias ideais (veja mais sobre estimativas por pontos aqui).

Existe um site bem interessante onde é possível jogar online o Planning Poker com sua equipe: planningpoker.com. Mas note que o poker real, com cartas de papel, é mais recomendável e geralmente mais ágil. Existem vários sites que fornecem as cartas para impressão, como: sprintplanning.com (para mais, deem uma olhada nas referências da Wikipedia).

Aqui tem uma explicação bem legal sobre como funciona a dinâmica do jogo:www.crisp.se/planningpoker

Links que serviram de base para este post 

http://www.brasiltech.net/agilez/2009/12/13/mais-agilidade-em-suas-estimativas-com-o-planning-poker/