Wormhole

Essa é uma tira rapidinha, mas que demonstra muito bem a realidade (infelizmente) na grande maioria dos projetos de software:

 

O objetivo desse script é importar de uma forma bem simples, uma planilha XLS do Excel para o Banco de Dados.

O procedimento é útil principalmente quando o cliente já possui, por exemplo, uma base de dados legada e a única fonte é uma planilha do Excel.

Para isso, utilizaremos a função OPENROWSET.

/* 
 * Projeto: Importação de planilhas Excel no SQL Server 
 * Autor: Luis Fernando de Souza Santos
 * Data: 17/01/2010 
 * Versão SQL Testada: 2008 Express Edition
**/

-- Habilitando as opções avançadas 
-- Por default e por questões de segurança, essas 
-- opções vêm desabilitadas.
sp_configure
   'show advanced options', 1
reconfigure
sp_configure
   'Ad Hoc Distributed Queries', 1 
reconfigure

-- Criando a tabela com os meus atributos da planilha
create table funcionario(
   Código INT NOT NULL PRIMARY KEY,
   Nome VARCHAR(100) NOT NULL,
   Admissão SMALLDATETIME NULL,
   Departamento VARCHAR(100) NULL
);

-- Comando para importar a planilha na tabela
INSERT INTO FUNCIONARIO SELECT
   * FROM OPENROWSET ('Microsoft.Jet.OleDB.4.0',
   'EXCEL 8.0;Database=C:\departamento.XLS',Func$
);

-- Em "Database=C:\departamento.XLS',Func$", deve-se informar 
-- o nome do arquivo, seguido do nome da "planilha" + $.
-- Exemplo: Arquivo DEPARTAMENTO.XLS, Planilha Func.

-- Pronto! Aí para visualizar, é só dar um SELECT na tabela.

Para saber mais: http://msdn.microsoft.com/en-us/library/ms190312.aspx

Você deveria ser capaz de ver números dentro dos círculos na imagem abaixo. Se você não consegue vê-los talvez seja cego para algumas cores. Faça o teste.

Essa estranha característica é quase sempre uma herança genética e é mais comum em homens.

Mas não se preocupe, por mais estranho que parece isso é bem comum.

 

 

Mais um daqueles milhares de vídeos de acidentes engraçados... haha, mas é engraçado!! e a musica é legal.

Hibernate Tools Eclipse Plugin 

O Hibernate Tools facilita muito o desenvolvimento de aplicativos com Hibernate no Eclipse.

Algumas características são:

• * Engenharia reversa
• * Configurador do hibernate.cfg.xml
• * Editor de Hibernate HQL com intelisense
• * Execução de consultas e seus resultados
• * Gera código SQL
• * Ajuda a configurar arquivos hbm.xml ...e muito mais...

Alguns livros, como por exemplo o Visual C# 2008 passo-a-passo, recomendam fortemente o uso de implementação explícita de interface.

Considere o código;

interface IExemplo
{
    void imprime();
}

class ClasseA : IExemplo
{
    public void imprime() { }
    public void carrega() { }
}

class ClasseB : IExemplo
{
    void IExemplo.imprime() { }
    public void carrega() { }
}

class Program
{
    static void Main(string[] args)
    {
        ClasseA a = new ClasseA();
        a.imprime();
        a.carrega();

        IExemplo b = new ClasseB();
        b.imprime();
        // O método "carrega()" é inacessível a "b"!
    }
}

A questão é: dessa forma, o objeto “b” não pode acessar o método “carrega()”, então, eu perco o acesso aos métodos próprios da classe ClasseB?

Não é bem assim...

Essa implementação é boa para o caso de uma classe implementar várias interfaces que podem ter métodos com a mesma assinatura.

Acompanhe mais um exemplo;

interface IExemplo
{
    void imprime();
}

class Classe : IExemplo
{
    void IExemplo.imprime()
    {
        Console.WriteLine("Impressão da IExemplo");
    }

    void imprime()
    {
        Console.WriteLine("Impressão da classe");
    }

    static void Main(string[] args)
    {
        IExemplo ex = new Classe();
        ex.imprime();
        (ex as Classe).imprime();
        Console.ReadKey();
    }
}

• output
• Impressão da IExemplo
• Impressão da classe

Não, você não perde acesso aos métodos da classe, mas programar com abstração leva a esse tipo de "problema" (se é que podemos chamar isso de problema).

O que você pode fazer é, já que a variável é do tipo interface, e a classe implementa essa interface, a variável pode sofrer casting pro tipo da classe, fazendo você "ganhar" acesso a tudo que a classe tem de métodos.

E sim, é muito mais limpo programar DESTA forma, do que criar um bilhão de classes com vários métodos diferentes e sair criando levas de objetos pra poder acessar métodos distintos quando tudo que você tem de fazer é criar uma abstract class ou uma interface.

*** Pode ter certeza, você NÃO vai achar uma dica dessas facilmente por aí!!! ***

A documentação do Hibernate é riquíssima e muito consistente, mas é ridículo ser obrigado a parar bruscamente o seu trabalho para recorrer ao website/pdf/chm, ou seja lá qual o meio de acesso que você usa para buscar informações ou tirar dúvidas, muitas vezes simples, na vasta documentação deste poderoso framework.

Eu já cheguei a desistir de entender melhor as características de um determinado método depois de me perder nos milhares de tópicos.

Esse processo trabalhoso se torna ainda mais desnecessário quando usamos uma ferramenta de rápido desenvolvimento, as famosas IDEs, como por exemplo o Netbeans. Isso porque elas nos dão a possibilidade de acessar a documentação de qualquer biblioteca ou projeto diretamente no código, sem a necessidade de quebrar a linha de raciocínio só para descobrir quais são as sobrecargas (overload) para um determinado método. É fácil perceber isso quando usamos objetos da API do próprio Java, um exemplo seria o String.

Aqui vai uma print screen com o javadoc do Hibernate já funcionando;

Resolvi fazer este tutorial quando percebi que não é fácil encontrar a documentação mais nova e muitos fóruns tem tópicos e tópicos com dúvidas sobre isso.

Bom, chega de enrolação, vamos ao que interessa.

Ferramentas usadas neste tutorial;

• * Netbeans 6.8
• * Hibernate-distribution-3.3.2.GA

Para fazer uso da documentação diretamente no código você precisa associar sua biblioteca (library) ou projeto a um arquivo Javadoc (.jar contendo toda a documentação) específico daquela biblioteca ou projeto.

Deste a versão 3.2.6 o Hibernate não vem com seu Javadoc (não me pergunte porque) e muitos fazem uso da documentação antiga, já seria de grande ajuda e claro que quebra o galho, mas eu não fiquei satisfeito e tratei de procurar pela versão mais nova.

Ela se encontra aqui ==>

hibernate-core-3.3.2.GA-javadoc.jar

Se quiser, aproveite também pra pegar o código fonte aqui ==>

hibernate-core-3.3.2.GA-sources.jar

Crie um projeto no Netbeans e adicione as bibliotecas do Hibernate como de costume.

• Agora clique com o botão direito sobre o Projeto
• Selecione a opção Propriedades (Properties)
• Clique em Bibliotecas (Libraries).

Muita atenção nessa parte...

• Clique sobre a biblioteca com a qual você quer adicionar o javadoc
• No caso do Hibernate 3.3.2 é a hibernate3.jar
• Do lado direito dessa mesma tela tem a opção Editar (Edit), clique nela
• Agora ficou fácil, né? é só clicar em Procurar (Search)
• Selecione o arquivo hibernate-core-3.3.2.GA-javadoc.jar
• Marque OK em todas as telas e pronto!

É só isso! Seu projeto já está pronto, faça os testes.

Se tiver qualquer dúvida comente aqui que eu respondo o mais rápido possível.

Obrigado pela visita e boa sorte!!!

O banco de dados PostgreSQL não possui nativamente um tipo auto-incremento, mas podemos usar da malandragem pra dar um “jeitinho”...

Analise o código;

create table Produtos (    
    id integer not null,     
    descricao char(60),     
    preco decimal (15,2),     
    constraint primary key (id_produto)     
);

Esse código compila normalmente numa base de dados do PostgreSQL, mas o campo id da tabela Produtos não será auto-incremento, ele apenas não aceita valores repetidos.

Existem, basicamente, duas maneiras de se criar um campo que gear um valor automaticamente.

1 - Você pode criar uma sequence, da seguinte forma:

create sequence nome_da_sequence;     
create table produtos (     
    id_produto integer defeault nextval('nome_da_sequence') not null,     
    descricao char(60),     
    preco decimal (15,2),     
    constraint primary key (id_produto)     
);

2 – Com a ajuda dos tipos seriais. Os tipos de dados serial e bigserial não são tipos verdadeiros, mas meramente uma notação conveniente para definir colunas identificadoras únicas (semelhante à propriedade AUTO_INCREMENTO existente em alguns outros bancos de dados).

create table Produtos (   
    id serial not null,   
    descricao char(60),   
    preco decimal (15,2),   
    constraint primary key (id_produto)   
);

Isso fará com que uma sequence seja criada automaticamente com o seguinte nome: produtos_id_seq. Você pode ver a estrutura da sequence digitando no banco o comando: \d produtos_id_seq.

Boa Sorte!!!

Olá, recentemente eu estava fazendo alguns testes com um framework para persistência de dados em Java, o Hibernate (logo mais eu posto alguma coisa sobre ele) e percebi que um dos melhores bancos de dados neste cenário seria o PostgreSQL.

O PostgreSQL sempre teve muita fama de ser o mais robusto banco de dados de código aberto, mas muitos, inclusive eu, acreditam que tamanha performance só pode ser alcançada em servidores Linux, mesmo assim têm de ser muito bem configurados. Ele também se sai bem em ambiente Windows, mas a diferença é enorme em comparação ao Linux.

Bom, mas não é exatamente isso que quero propor neste post.

Here i go… Tive um pequeno contra-tempo durante a instalação deste banco no meu PC com Windows Seven e, apesar de simples, não foi fácil encontrar a resposta para o problema.

Tentei por duas vezes e o instalador apresentava o mesmo erro;

Não foi possível ler o arquivo postgresql.config. A instalação pode não ter sido completada com sucesso!

A versão que eu usei foi a seguinte: postgresql-8.4.2-1-windows.exe.

Apesar da incômoda mensagem de erro, o instalador terminou o processo, mas não iniciou o serviço do PostgreSQL automaticamente e, qual não foi a minha surpresa, ao tentar fazer isso manualmente simplesmente não dava, tentei até com usuários diferentes, mas era impossível, o serviço não iniciava e em virtude disso, é claro, não foi possível fazer nenhuma conexão com meu mais novo banco de dados.

Acontece que o culpado, de novo, é nosso “grande amigo” UAC – User Account Control, mas calma!! Não precisa desativa-lo só pra uma simples instalação. Basta clicar com o botão direito sobre o instalador do PostgreSQL e selecionar a opção “Executar como Administrador”, pronto agora é possível terminar o processo de instalação com sucesso, ufa.

Ah, e ele inicia o serviço automaticamente, não se preocupe com isso. XD

 

Um vídeo superdivertido que achei por aí. É bem didático até, mostra como “exatamente” é o funcionamento do Sistema Operacional Microsoft Windows.

O interessante é a maneira totalmente descontraída e descompromissada que o vídeo narra os procedimentos “dentro” de um computador.

Só pra se ter uma idéia da doidera, o carinha que parece um feijão preto aí embaixo representa o processador e corre pra lá e pra cá freneticamente tentando solucionar os problemas para o usuário e, claro, nem tudo dá certo...

 

Aproveitando que falta menos de um mês para a 6ª e última temporada de LOST, a ABC liberou uma imagem que está deixando fãs malucos mundo afora.

Uma alusão à Santa Ceia de Leonardo Da Vinci foi criada com os principais personagens, na frente de uma ruína das Estações Dharma, com a comida obviamente sendo da Iniciativa Dharma.

Que comecem as teorias!

 

(clique para ampliar)

Hahaha, essa foi demais, após um assalto dois meliante fogem com a ajuda de uma Scooter, mas eles não contavam com astúcia de homem.

Reparem no vídeo, ele esperou o momento exato para simplesmente jogar sua bicicleta contra os assaltantes...

Se fosse por aqui no Brasil, duvido muito que alguém teria tanta coragem.

 

E aqui vai mais uma dica legal, dessa vez é um programa interessante para quem gostar de manter suas contas em dia e de fácil acesso através do computador.

O FinanceDesktop é um software gratuito para gestão financeira, com opções que vão além da gestão de gastos familiares, com funções para organizar investimentos e aplicações, múltiplas contas e dados que são atualizados constantemente.

O software requer um cadastro no site e conexão de internet ativa, já que vários dados e até notícias são carregados automaticamente pelo programa, centralizando todas as informações e tarefas financeiras do usuário.

O FinanceDesktop possui um calendário, permitindo que todos os compromissos e gastos do usuário sejam definidos com precisão. Para não errar nas contas, o software possui o ícone de calculadora, que na verdade é um atalho para a calculadora do Windows.

Mesmo com uma interface limpa, o funcionamento do FinanceDesktop não é dos mais intuitivos, exigindo dedicação do usuário para se familiarizar com seu funcionamento, mas não se assuste com isso, depois de pegar o jeito, o que não deve levar mais do que alguns minutos, fica fácil a manutenção do dados.

Um dos trunfos é com certeza o sistema de relatórios totalmente personalizável como se pode ver na tela abaixo.

Financedesktop - Site do fabricante: http://www.financedesktop.com.br/

 

Estava lendo o blog do André Nobre e achei ótimos artigos sobre o funcionamento do Garbage Collector, é obrigatório para todo desenvolvedor entender o funcionamento do GC e para quem não entende ou ainda ficou alguma dúvida é leitura obrigatória.

Garbage Collector I
Garbage Collector II

No último post eu falei sobre um Gerador de CPF e CNPJ muito interessante, mas era um serviço online e não permitia acesso ao código fonte.

E como eu sou bastante curioso, pesquisei bastante e encontrei um projeto construído em JAVA, é um projeto simples, mas poderoso e de código aberto.

Ah, e ele também gera números de cartão de crédito! Impressionante.

Descrição do autor:

Como diz o ditado: a necessidade faz o sapo pular, precisei fazer este programa, primeiro como é de costume, busca no google para ver se já não existe algo pronto, acabei encontrado um conjunto de classes intitulada: utilities4, que até agora não sei quem é ou são os desenvolvedores, muita coisa pronta, algumas pequenas modificações para adaptar a realidade do que eu precisava e feito, um programa para gerar CPF, CNPJ e números de Cartões de Crédito. O Projeto foi desenvolvido utilizando o Netbeans 6.5, utilizei alguns conceitos e classes interessantes para que quiser aprender um pouco mais de JAVA, principalmente a utilização de Thread´s e controle da Área de Transferência. Estou disponibilizando o sistema com o código fonte, se alguém tiver uma sugestão de melhoria, ou melhorar o código, poste seu comentário. Lembrando que a recomendação da utilização deste projeto é somente para aprendizagem e de testes.

 

Disponibilizei pra download no seguinte link (183 KB):

Aqui vai mais uma preciosa dica, o Gerador de CPF e CNPJ possibilita a criação aleatória de Humanos (nome e CPF válido), e Empresas (razão social e CNPJ válido) para testes em sistemas.

O projeto foi desenvolvido para auxiliar o preenchimento de cadastros de pessoa física e jurídica em sistemas. Todas as informações geradas pelo gerador são fictícias, claro, mas é uma mão na roda na hora fazer testes de validação de dados em sistemas.

Projetos parecidos existem aos montes por aí, mas vai ser difícil encontrar outro tão rápido e consistente. Ele permite gerar até 10 indivíduos de cada vez, incluindo os nomes.

Se eu der somente UMA dica em 2010 e for esta, já terá valido o ano.

É uma espécie de ovo de páscoa muito ÚTIL, escondido pela Microsoft e que facilita muito a vida de um usuário do Windows 7: GodMode. Não tem “dá munição infinita” e “todas as armas”, mas fora isso...

O truque é simples: Crie uma pasta, em qualquer lugar. Renomeie para:

GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

ou, se preferir, o nome abaixo tem o mesmo efeito, porém, menos charmoso;

SuperControlPanel.{ED7BA470-8E54-465E-825C-99712043E01C}

Pronto. Você passa a ter um ícone que abre uma lista de todas as ações de administração e manutenção de seu computador, em uma única, simples e objetiva listagem. Posso calcular JÁ que isso irá me economizar horas e horas até o final do ano.

 

Nem sempre tipos anônimos são a melhor opção para armazenar o resultado de uma Linq query.

Os tipos anônimos (Anonymous Types) são realmente muito práticos numa ling query. Mas e quando você precisa retornar um elemento dessa query?

Criar um método para retornar um tipo anônimo poderia ser uma solução, mas eu prefiro manter a característica mais marcante da linguagem C#, o “strong typed language” ou “linguagem fortemente tipada”.

No exemplo abaixo, eu estou criando uma nova classe (ResultSet) que vai servir apenas para armazenar o resultado de uma linq query sobre uma lista de fornecedores personalizada.

using System;
using System.Collections.Generic;
using System.Linq;

namespace TiposAnonimos
{
    class Program
    {
        //Classe de persistencia
        class Fornecedor
        {
            public int ID { get; set; }
            public string Nome { get; set; }
            public string CNPJ { get; set; }
            public string Telefone { get; set; }
            public string Rua { get; set; }
            public string Bairro { get; set; }
            public string Cidade { get; set; }
            public string CEP { get; set; }
            public string Estado { get; set; }
        }

        //Defina uma classe para conter o resultado da linq query
        class ResultSet
        {
            public int Codigo { get; set; }
            public string Nome { get; set; }
            public string CNPJ { get; set; }
        }

        public static void Main(string[] args)
        {
            Fornecedor f1 = new Fornecedor();
            //Populando uma lista de fornecedores
            //Não vou preencher todos os dados por uma questão de espaço
            List lista = new List()
            {
                new Fornecedor()
                    {ID=1, Nome="Fornecedor1", CNPJ="11.111.111/1111-11"},
                new Fornecedor()
                    {ID=2, Nome="Fornecedor2", CNPJ="22.222.222/2222-22"},
                new Fornecedor()
                    {ID=3, Nome="Fornecedor3", CNPJ="33.333.333/3333-33"},
                new Fornecedor()
                    {ID=4, Nome="Fornecedor4", CNPJ="44.444.444/4444-44"},
                new Fornecedor()
                    {ID=5, Nome="Fornecedor5", CNPJ="55.555.555/5555-55"},
                new Fornecedor()
                    {ID=6, Nome="Fornecedor6", CNPJ="66.666.666/6666-66"},
                new Fornecedor()
                    {ID=7, Nome="Fornecedor7", CNPJ="77.777.777/7777-77"},
                new Fornecedor()
                    {ID=8, Nome="Fornecedor8", CNPJ="88.888.888/8888-88"},
                new Fornecedor()
                    {ID=9, Nome="Fornecedor9", CNPJ="99.999.999/9999-99"},
            };

            //Em fim, a ling query que retorna apenas alguns dados essenciais
            //Ideal para preencher um DataGridView, por exemplo
            var query = (from f in lista
                        select new ResultSet()
                        {
                            Codigo = f.ID,
                            Nome = f.Nome,
                            CNPJ = f.CNPJ
                        }).ToList();

            //Mostra os resultados na tela
            query.ForEach(f =>
                {
                    Console.WriteLine("Codigo: {0} || Nome: {1} || CNPJ: {2}",
                        f.Codigo, f.Nome, f.CNPJ);
                });
            Console.ReadKey();
        }
    }
}//desconsidere essa linha, é um bug do HTML (O_o)

/**
 * ValidaCPF.java
 * 
 * Criado em 4 de janeiro de 2010, 16:00
 */
package utils;

import javax.swing.InputVerifier;
import javax.swing.JComponent;
import javax.swing.JTextField;

/**
 * A classe ValidaCPF é usada para a validação de CPF em campos de 
 * textos em uma interface gráfica. Esta classe deve ser usada 
 * como o verificador de entrada de dados em componentes como um
 * JTextField.
 * 
 * @author Luis Fernando de Souza Santos
 *
 */
public class ValidaCPF extends InputVerifier {

	/** (non-Javadoc)
	 * @see javax.swing.InputVerifier#verify(javax.swing.JComponent)
	 */
	@Override
	public boolean verify(JComponent component) {
		return verificaCampo(component);
	}
	
	/**
	 * O método verificaCampo faz a efetiva verificação do CPF.
	 * 
	 * @param component o componente do tipo JTextField.
	 * @return true se o CPF é válido, false caso contrário.
	 */
	protected boolean verificaCampo(JComponent component) {
		boolean eValido = false; // Assume que o CPF é inválido
		String cpf = null;
		if (component instanceof JTextField) {
			JTextField tmp = (JTextField) component;
			cpf = tmp.getText();
		}
		else {
			return eValido;
		}
                // Os caracteres do CPF
		char[] caracteres = cpf.toCharArray();
                // Transformados em dígitos
		int[] digitos = new int[caracteres.length];
                // Variáveis temporárias
		int somaNove = 0, somaDez = 0;
                // Os dígitos de verificação do CPF
		int digitoDez = 0, digitoOnze = 0;
		
		if (caracteres.length != 11) {
			return eValido; // O CPF deve ter exatamente 11 dígitos.
		}
		
		for (int count = 0; count < caracteres.length; count++) {
			if (!Character.isDigit(caracteres[count])) {
				return eValido;	// Se não for um dígito não é um CPF válido.
			}
		}
		
		// Transforma os caracteres em dígitos numéricos
		for (int count = 0; count < caracteres.length; count++) {
			digitos[count] = Character.getNumericValue(caracteres[count]);
			int valor = 0;
			// Soma os nove primeiros dígitos multiplicados 
                        // por um valor determinado.
			if (count < 9) {
				valor = digitos[count] * (11 - (count + 1));
				somaNove += valor;
			}
		}
		
		// Usa a soma para calcular o primeiro dígito verificador.
		digitoDez = 11 - (somaNove % 11);
		if (digitoDez > 9) {
			digitoDez = 0;
		}
		
		// Se o décimo dígito calculado for diferente do décimo dígito passado
		// o CPF não é válido.
		if (digitoDez != digitos[9]) {
			return eValido;
		}
		
		// Soma os 10 primeiros dígitos multiplicados por um valor 
                // determinado.
		for (int count = 0; count < digitos.length; count++) {
			int valor = 0;
			if (count < 10) {
				valor = digitos[count] * (12 - (count + 1));
				somaDez += valor;
			}
		}
		
		// Usa a soma para calcular o segundo dígito verificador.
		digitoOnze = 11 - (somaDez % 11);
		if (digitoOnze > 9) {
			digitoOnze = 0;
		}
		
		// Se o décimo primeiro dígito for diferente do dígito passado, 
		// o CPF não é válido.
		if (digitoOnze != digitos[10]) {
			return eValido;
		}
		
		// Se passou por todos os testes o CPF é válido
		eValido = true;
		
		return eValido;
	}
}