Sei que estou um pouco sumido das postagens, mas é por uma boa causa, depois que ingressei no mestrado da UFSCar estou tendo que estudar para alguns temas que serão abordados nas disciplinas do programa, e sendo assim hoje estou trazendo alguns assuntos que estou estudando, e hoje trago para vocês os assuntos da disciplina de Aspectos Formais da Computação.

Além de estudar com alguns livros (achei esse livro disponível: Introdução a Teoria da Computação, muito didático, vale a pena dar uma olhada),  apostilas e apresentações (Slides Teoria da Computação – USP e Teoria da Computação (mais simplificada), estou me utilizando de vídeo aulas, que estão sendo bem esclarecedoras. E assim como fiz no post sobre a Zend Framework eu separei as vídeo aulas que estão me ajudando a compreender os assuntos da disciplina, em destaque para as aulas do Prof. Eduardo, no seu canal do YouTube encontrei 8 vídeos publicados que tratam desde os conceitos básicos de conjuntos, alfabetos e cadeias, até Máquina de Estados Finitos com Expressões Regulares, veja:

• Vídeo Aula 1 – Formalismos, Classes de Linguagens e Autômato Finito Determinístico
• Vídeo Aula 2 – Máquina de Estados Finitos
• Vídeo Aula 3 – Autômato Finito Determinístico (continuação)
• Vídeo Aula 4 – Autômato Finito Determinístico vs. Autômato Finito Não Determinístico
• Vídeo Aula 5 – Equivalência Autômato Finito Determinístico e Não Determinístico
• Vídeo Aula 6 – Autômato Finito Não Determinístico com transições ε
• Vídeo Aula 7 – Linguagens e Expressões Regulares
• Vídeo Aula 8 – Autômatos Finitos e Expressões Regulares

Veja aqui outros vídeos interessantes que estou estudando:

• Máquina de Turing, UFAL (a explicação no vídeo não é muito didática, mas a animação ajuda no entendimento)
• Autômatos com pilhas, 1:35 hrs de aula, em espanhol (!!!)
• Curso de Estrutura de Dados (USP), vale a pena dar uma olhada no canal do YouTube

Então é isso ai galera, conforme eu for tendo tempo, vou postando algo para vocês!

Abração,

Tiago.

Hoje eu vou tratar de um assunto da época da faculdade, o cálculo da previsão de vendas de um determinado produto, com base nas vendas anteriores, para tal iremos utilizar o PostgreSQL e PHP.

Mas antes de mais nada, estou disponibilizando um documento do Excel com os mesmos dados da figura abaixo, juntamente com um gráfico contendo os resultados e informações importantes como o valor do r² e a equação do nosso modelo. Também achei importante disponibilizar os slides utilizados pelo Prof. Darlan quando este assunto foi ministrado, lá você irá encontrar mais conteúdo e uma bagagem teórica solida e enxuta.

Primeiramente vamos ao nosso problema:

Quanto eu devo investir em publicidade para ter um determinado ganho em vendas?

Quando nós chegarmos ao ponto de extrair os dados do Postgres perceberemos que na modelagem do banco estes dados (investimento e vendas) não tem nenhuma correlação, veja bem, do ponto de vista da modelagem. Por isso é muito importante que você compreenda bem nosso problema, e para simplificar na tabela abaixo temos os investimentos (ou gastos) com publicidade representado pela variável x, e as vendas representadas pela variável y. Note que além desses dados temos outros como x², y² e xy, que iremos utilizar posteriormente.

Veremos estes mesmos dados a seguir quando estivermos trabalhando no banco de dados, coloquei a tabela de ante-mão para abstrair melhor nosso trabalho, e  na seção seguinte do post iremos abordar os conceitos matemáticos envolvidos e os nomes das colunas (as variáveis) irão aparecer nas fórmulas, e como já vimos estruturadamente, ficará mais fácil.

O objetivo então é que possamos construir uma aplicação que nos informe qual será o valor que iremos vender, baseando-se no valor que iremos investir em publicidade.

Ahh, antes que os mais críticos se envolvam, gostaria de dizer que este é um exemplo simples, se você quiser pode melhora-lo de acordo com a sua necessidade

A matemática por traz do cálculo

Antes que muitos torçam o nariz ou pulem essa parte, já vou adiantando que nossa matemática será breve e simples. É fundamental que você entenda essas fórmulas (além de ler os slides que falei acima) para entender como funciona o nosso modelo.

E por falar em modelo, aqui temos um estatístico probabilístico, de regressão linear simples. Veja a representação do nosso modelo de equação abaixo:

Aqui temos que a variável y é explicada pela variável x, que por sua vez é explicativa. Então veja que, se estamos representando os gastos com publicidade por x, e as vendas por y, temos que os gastos com publicidade é que vão determinar o valor das vendas.

Note também que temos dois coeficientes, chamados de a e b. As duas fórmulas a seguir irão utilizar os nossos dados que estão na tabela (conforme a figura da primeira seção), que na  verdade iremos regastar do Postgres. Veja que abaixo temos a representação da fórmula onde iremos encontrar o valor de a:

Você deve ter percebido que para calcular o valor de a, antes é necessário obter o valor de b, pois bem, abaixo está a fórmula para o cálculo, veja um detalhe importante: o valor de n é exatamente o número de linhas da nossa tabela (ou o número de registros no banco de dados).

Agora que você já tem as duas fórmulas poderá chegar na equeção linear do nosso modelo, que será parecida com esta:

 y = 2,0754 + 2,0884.x

Como saber se o modelo é confiável?

Para sabermos se o nosso modelo é confiável contaremos com o Coeficiente de Correlação de Person, ou o famoso r². Podemos calcular o valor do nosso coeficiente com a singela fórmula abaixo:

O resultado de r², irá variar entre -1 e 1, de forma que dependendo da variação, ela terá estes significados:

• r² = -1 : Existe uma correlação inversa entra as variáveis, ou seja, quando uma aumenta a outra diminui.
• r² = 0 : Modelo ruim, quanto mais próximo de 0, menos acertivo será seu modelo.
• r² = 1 : Significa que seu modelo é muito bom! Ou seja, quanto mais próximo de 1, melhor!

No nosso exemplo, r² é de aproximadamente 0,93 e observe que ele está bem próximo de 1, o que nos indica que nosso modelo é consistente.

Construção das tabelas, queries, e dados no PostgreSQL

Este é o ponto mais importante do trabalho, aqui é onde iremos armazenar os dados que servirão de base para construírmos o modelo estatístico de previsão, para isso tome como base as duas tabelas a seguir conforme o modelo mostrado anteriormente:

CREATE TABLE investimento_publicidade (
	cod_investimento SERIAL,
	valor_investimento DOUBLE PRECISION NOT NULL,
	data_realizacao TIMESTAMP NOT NULL DEFAULT NOW(),
	PRIMARY KEY (cod_investimento)
);

CREATE TABLE vendas (
	id_produto SERIAL,
	nome VARCHAR(100) NOT NULL,
	preco_unitario DOUBLE PRECISION NOT NULL,
	quantidade_vendida INTEGER NOT NULL,
	PRIMARY KEY (id_produto)
);

Agora iremos abastacer o nosso modelo com os mesmos dados que utilizamos acima. Para agilizar e para podermos testar depois, disponibilizei o script SQL com as instruções INSERT abaixo:

INSERT INTO investimento_publicidade (valor_investimento) VALUES (3);
INSERT INTO investimento_publicidade (valor_investimento) VALUES (4);
INSERT INTO investimento_publicidade (valor_investimento) VALUES (8);
INSERT INTO investimento_publicidade (valor_investimento) VALUES (12);
INSERT INTO investimento_publicidade (valor_investimento) VALUES (14);

INSERT INTO vendas (nome, preco_unitario, quantidade_vendida) VALUES ('Produto A', 7 , 1);
INSERT INTO vendas (nome, preco_unitario, quantidade_vendida) VALUES ('Produto B', 14, 1);
INSERT INTO vendas (nome, preco_unitario, quantidade_vendida) VALUES ('Produto A', 15, 1);
INSERT INTO vendas (nome, preco_unitario, quantidade_vendida) VALUES ('Produto C', 28, 1);
INSERT INTO vendas (nome, preco_unitario, quantidade_vendida) VALUES ('Produto C', 32, 1);

Muito bem! Agora temos os nossos dados, e neste ponto vamos extaí-los do banco para elaborarmos a equação do nosso modelo de previsão com o PHP!

Então, considere as duas queries abaixo, primeiramente a query que nos retornará os valores investidos em publicidade:

SELECT SUM(valor_inestimento) AS x_somatoria_invest_publicidade, SUM(valor_inestimento^2) AS x_quadrado
FROM investimento_publicidade

Veja o que estamos retornando nesta query: a nossa variável x, que é a somatória dos valores investidos em publicidade e o x², que iremos utilizar nas fórmulas.

E agora a query com os valores das vendas:

SELECT SUM((preco_unitario*quantidade_vendida)) AS y_somatoria_vendas, SUM((preco_unitario*quantidade_vendida)^2) AS y_quadrado
FROM vendas

Ok, temos retorno das variáveis y e y², repare que eu fiz umas brincadeirinhas, como a multiplicação do valor vendido pelo preço unitário, se você quiser pode brincar um pouco com os modelos depois alterando estes valores diretamente na tabela vendas.

NOTA: Eu poderia realizar toda a previsão de vendas somente dentro do Postgres, mas aqui quero utilizar o máximo de ferramentas possíveis, a previsão de vendas somente no PostgreSQL fica para um próximo post ok? =)

Exibição do modelo e simulação de dados com PHP

Veja abaixo o código de uma classe que irá realizar tanto os cálculos quanto as queries no Postgres, os comentários no código já explicam o que está acontecendo:

class PrevisaoVendas
{
	/**
	 * Atributo estático onde armazenaremos nosso objeto PDO para nossa comunicação com o banco de dados.
	 */
	private static $conn;

	/**
	 * Construtor da classe onde criamos e armazenamos nosso objeto PDO.
	 */
	public function __construct()
	{
		$opcoes_conexao = array(PDO::ATTR_ERRMODE    => PDO::ERRMODE_EXCEPTION,
								PDO::ATTR_PERSISTENT => true);

		self::$conn = new PDO("pgsql:host=127.0.0.1 dbname=PREVISAO_VENDAS", "postgres", "senha", $opcoes_conexao);
	}

	/**
	 * Método responsável por retornar um objeto (stdClass) com os valores do x e x quadrado (investimento em publicidade)
	 */
	private function getValoresInvestimentosX()
	{
		$sql = "SELECT SUM(valor_inestimento) AS x_somatoria_invest_publicidade, SUM(valor_inestimento^2) AS x_quadrado "
		     . "FROM investimento_publicidade";

		$stmt = self::$conn->prepare($sql);
		$stmt->execute();

		return $stmt->fetchObject();
	}

	/**
	 * Método responsável por retornar um objeto (stdClass) com os valores do y e y quadrado (vendas)
	 */
	private function getValoresVendasY()
	{
		$sql = "SELECT SUM((preco_unitario*quantidade_vendida)) AS y_somatoria_vendas, SUM((preco_unitario*quantidade_vendida)^2) AS y_quadrado "
			 . "FROM vendas";

		$stmt = self::$conn->prepare($sql);
		$stmt->execute();

		return $stmt->fetchObject();
	}

	/**
	 * Método que calcula o valor de xy, a dica é você olha no manual do PHP as funções array_combine e array_sum
	 */
	private function getValorXY()
	{
		/**
		 * Obtendo os valores de x;
		 */
		$stmt = self::$conn->prepare("SELECT valor_inestimento AS x FROM investimento_publicidade LIMIT 5");
		$stmt->execute();

		$x = array();

		while($rows = $stmt->fetchObject())
			$x[] = $rows->x;

		/**
		 * Obtendo os valores de y;
		 */
		$stmt = self::$conn->prepare("SELECT preco_unitario*quantidade_vendida AS y FROM vendas LIMIT 5");
		$stmt->execute();

		$y = array();

		while($rows = $stmt->fetchObject())
			$y[] = $rows->y;

		/**
		 * Calculando o valor da soma de xy
		 */
		$xy_aux = array_combine($x, $y);

		$xy = array();

		foreach($xy_aux as $key => $value)
			$xy[] = $key * $value;

		return array_sum($xy);
	}

	/**
	 * Obtem o número de registros de vendas, o "n" utilizado nas equações, observe que o número de vendas poderá não ser igual ao número de
	 * investimentos, caberá a você criar um mecanismo para definir que sempre os dados analizados estarão na mesma proporção e consistentes,
	 * uma dica é a utilização de LIMIT e OFFSET.
	 */
	private function getNumVendas()
	{
		$sql = "SELECT COUNT(*) FROM vendas";

		$stmt = self::$conn->prepare($sql);
		$stmt->execute();

		return $stmt->fetchColumn();
	}

	/**
	 * Método onde estamos resolvendo a equação para encontrar o valor de "a".
	 */
	private function getValorEquacaoA()
	{
		$x = $this->getValoresInvestimentosX();
		$y = $this->getValoresVendasY();
		$n = $this->getNumVendas();
		$b = $this->getValorEquacaoB();	

		$a = ($y->y_somatoria_vendas - ($b * $x->x_somatoria_invest_publicidade)) / $n;

		return $a;
	}

	/**
	 * Método onde estamos resolvendo a equação para encontrar o valor de "b".
	 */
	private function getValorEquacaoB()
	{
		$x  = $this->getValoresInvestimentosX();
		$y  = $this->getValoresVendasY();
		$n  = $this->getNumVendas();
		$xy = $this->getValorXY();		

		$b = (($n * $xy) - ($x->x_somatoria_invest_publicidade * $y->y_somatoria_vendas)) / (($n * $x->x_quadrado) - pow($x->x_somatoria_invest_publicidade, 2));

		return $b;
	}

	/**
	 * Método para a identificação do valor de r quadrado, onde veremos que conforme o valor do índice teremos o nível de confiabilidade do modelo.
	 */
	public function getValorRQuadrado()
	{
		$x  = $this->getValoresInvestimentosX();
		$y  = $this->getValoresVendasY();
		$n  = $this->getNumVendas();
		$xy = $this->getValorXY();	

		$r = (($n * $xy) - ($x->x_somatoria_invest_publicidade * $y->y_somatoria_vendas)) / (sqrt(($n * $x->x_quadrado) - pow($x->x_somatoria_invest_publicidade, 2)) * sqrt(($n * $y->y_quadrado) - pow($y->y_somatoria_vendas, 2)));

		$r_quadrado = pow($r, 2);

		return $r_quadrado;
	}

	/**
	 * Método para obteção de uma string contendo a fórmula do modelo.
	 */
	public function getStringFormulaModeloPrevisor()
	{
		$a = $this->getValorEquacaoA();
		$b = $this->getValorEquacaoB();

		$string = "y = " . number_format($a, 4, ",", "") . " + " . number_format($b, 4, ",", "") . ".x";

		return $string;
	}

	/**
	 * Método que capta um dado valor em investimento de publicidade, e por meio do nosso modelo, retorna a previsão das vendas.
	 */
	public function getValorSimuladoVendas($valor_invest_publicidade)
	{
		$a = $this->getValorEquacaoA();
		$b = $this->getValorEquacaoB();

		$y = $a + ($b * $valor_invest_publicidade);		

		return $y; // Nosso valor estimado das vendas.
	}
}

Veja um exemplo de utilização da classe:

$preview = new PrevisaoVendas();

$preview->getStringFormulaModeloPrevisor(); // Irá nos retornar a fórmula.
$preview->getValorRQuadrado();              // Valor do r quarado com a precisão do nosso modelo.
$preview->getValorSimuladoVendas(10.0);     // Retorna o valor das vendas, se no caso, invesrtirmos $ 10,00 em propaganda.

Então amigos, é isso ai, espero que vocês tenham gostado da simplória abordagem. Eu gostaria muito de saber das experiências de vocês, então fiquem a vontade para comentar!

Referências:

• Análise de Regressão – Slides
• Wikipedia – Coeficiente de Correlação de Person
• PHP Documentation – Função pow()
• PHP Documentation – Função sqrt()
• PHP Documentation – Função array_combine()
• PHP Documentation – Função array_sum()

Abraços,

Tiago.

Olá novamente meus caros amigos!

Este é o meu primeiro post de 2012! E primeiramente gostaria de agradecer a todos vocês que vem acompanhando meu trabalho desde o começo, nesses 4 meses  de blog, e digo que nesse curto período de tempo já obtive uma ótima experiência compartilhando um pouco do meu conhecimento e dia a dia aqui com vocês.

Neste novo ano que se inicia minha vida passará por grandes mudanças, estou deixando a vida corporativa para me dedicar a carreira acadêmica, como vocês já devem ter visto no post sobre meu mestrado, e assim estou finalizando 2011 muito feliz e realizado, apesar de não ter sido um dos anos mais produtivos da minha vida, no entanto tenho a esperança de agora em 2012 poderei realizar tudo que sonhei. Tenho certeza que meu trabalho na UFSCar vai render bons frutos e me colocar onde eu sempre quis estar.

Quanto ao blog acredito que irei blogar o resto da vida, a experiência é fantástica e animadora quando se começa a colher os resultados do trabalho, e estou me referindo ao reconhecimento e renome que esta atividade traz. E falando mais sobre o blog, eu fiz uma especie de “raio-x” dos resultados e coloquei abaixo, e dedico o sucesso a você, meu caro leitor que acompanha meu trabalho!

O Blog em Números

Separei para vocês alguns números do blog, não são exagerados mas considero um bom resultado. Hoje estamos com cerca de 40 posts publicados com conteúdos novos ou releituras de temas mais batidos, além de mais de 90 rascunhos já titulados de assuntos que pretendo tratar aqui com vocês! E claro irão existir muitos que ainda virão no decorrer do ano.

Quanto ao tráfego não tenho do que reclamador em termos de números, estamos crescendo bem! Segundo o Google Analytics, em torno de 150% ao mês em visitas únicas, no mês de dezembro foram 700! As visualizações de página também evoluem de acordo, e posso dizer que o plugin do WordPress chamado Related Posts via Categories ajudou muito, pois além de baixar a taxa de rejeição de cerca de 70% para 49% no mesmo período, ainda expandiu as pageviews para mais de 2000!

Tenho que destacar também a indexação dos posts sobre PostgreSQL por parte do Planeta PostgreSQL. Além de ajudar muito na geração de novas visitas, também é uma honra, já que agora estamos dentro da Comunidade Oficial do PostgreSQL no Brasil, estou ficando muito feliz pois os dados revelam que o pessoal tem gostado da minha abordagem sobre o tema!

No entanto nem tudo são flores, existem dados que quero mudar em 2012, um deles é a origem do tráfego, sendo que hoje cerca de 80% é provida pelos sites de referência, e ai incluem-se também as redes sociais, e a porcentagem de visitas oriundas do Google é de  apenas 10% das visitas, e ainda o dado mais alarmante é que em todo o período do blog ainda não registrei visitas de outros buscadores, apesar de todos os relatórios apontarem que todo conteúdo está indexado. Dessa maneira eu gostaria de inverter essa proporção, para o blog “andar mais sozinho”.

Outro ponto que está me incomodando muito é a nota do Page Rank, que atualmente é de um bem redondo ZERO! Estou trabalhando para mudar, no fechamento do ano a Ferramenta para Webmasters do Google me retornava que haviam cerca de 1000 links para os conteúdos do blog, e espero que este ano suba cada vez mais!

O que esperar para 2012?

Como mencionei acima tenho muita coisa para escrever ainda e compartilhar com vocês! E espero que o conteúdo seja tão relevante para vocês quando é para mim! Sendo assim, o que esperar do blog para 2012? Um novo layout, a abordagem de novos temas como Java e Zend Framework. Também estou pensando seriamente em submeter alguns trabalhos no formato de palestras para os simpósios semestrais da Fatec Mococa (o que vocês acham disso fatecanos?) e claro disponibilizar o material aqui.

Assim espero que vocês que já acessam continuem e que possam trazer novos visitandes compartilhando do nosso conhecimento!

Abraços e um Feliz Ano Novo!

Tiago.

Olá novamente caros leitores!

Primeiramente me desculpem pela demora para liberar uma nova postagem sobre o Postgres, é que as últimas semanas foram muito movimentadas, realizei minha entrevista na UFSCar para o ingresso no programa de mestrado do Departamento de Computação e ainda na semana retrasada recebi a notícia da minha aprovação, então imaginem o tamanho da felicidade e a correria com as festas de fim de ano.

Bom, mas vamos ao que interessa, hoje irei falar sobre as triggers, ou funções de gatilho, como você queria chamar. Uma das coisas mais interessantes da implementação das funções no Postgres é que você pode escolher qual linguagem vai usar para programar sua trigger! Isso mesmo, então antes de mais nada, eu separei abaixo a lista de algumas linguagens, e o link para mais informações sobre elas, veja:

• PL/PGSQL
• PL/Tcl
• PL/Perl
• PL/Python
• PL/Java (veja aqui ou aqui como instalar a PL/Java)

Agora que você já sabe dessa maravilha do Postgres irei dizer que aqui, iremos exemplificar as triggers utilizando a PL/pgSQL. Mas antes da prática no código fonte, iremos trabalhar um pouco sobre a definição e funcionamento das triggers no PostgreSQL.

Você deve saber que os nossos gatilhos funcionam baseados em eventos, dois: before (antes de alguma coisa) e after (depois de alguma coisa). Explicando: você pode determinar que uma trigger dispare após (after) a inserção em determinada tabela do banco ou antes (before) da tal inserção, por exemplo.

É muito importante que você dê uma olhada abaixo na lista de variáveis que podem ser utilizadas dentro da estrutura da função da sua trigger, vale a pena dar uma lida, no entanto existem duas que a leitura é obrigatoria, que são a new e a old. Elas são usadas da seguinte maneira:

• NEW: No caso da trigger ser disparada por um INSERT a variável NEW irá abrigar os valores a ser inseridos, e caso seja um evento do tipo UPDATE, NEW irá conter a nova versão dos valores a serem atualizados (veja o exemplo no código abaixo).
• OLD: Esta variável é utilizada no caso do evento DELETE armazena os dados que estão sendo excluídos, e no caso do UPDATE a versão antiga dos dados.

O acesso dos dados se dá em ambas as variáveis dessa maneira: NEW.COD_CLIENTE, por exmplo. Abaixo você verá o exemplo de uma trigger.

Outras variáveis especiais que você pode usar:

• TG_NAME: Contém o nome do trigger que foi disparado.
• TG_WHEN: Contem quando o evento foi disparado, sendo BEFORE ou AFTER.
• TG_LEVEL: Diz em qual ponto da trigger.
• TG_OP: Tipo de operção que está sendo executada: INSERT, UPDATE ou DELETE.
• TG_RELID: Contém a ID do objeto que está disparando o gatilho.
• TG_RELNAME: Nome da tabela que disparou o gatilho (obsoleto).
• TG_TABLE_NAME: Nome da tabela que disparou o gatilho.
• TG_NAME_SCHEMA: Nome do schema onde está a tabela que disparou a trigger.
• TG_NARGS: Número de argumentos fornecidos para a Stored Function do trigger.
• TG_ARGV[]: Os argumentos que foram fornecidos.

Perguntas (quase) nunca feitas sobre triggers:

• Sabe-se que pode atrelar mais de uma trigger por tabela, então qual a ordem de execução das triggers?
  R: A ordem de execução é alfabética.
• Triggers podem ser recursivas?
  R: Sim! Os gatilhos podem executar comandos SQL, e os mesmos podem disparar outras triggers. Este cenário é conhecido como cascateamento de triggers, assim pode ser que a trigger passe a se “auto disparar”, ou seja, chamadas recursivas da própria trigger, fique atento a recursões infinitas!

Triggers na Prática

Agora vamos a parte pática irei realizar um único exemplo, neste link você e encontrar mais exemplos de triggers. No nosso, considere as duas tabelas abaixo:

CREATE TABLE funcionarios (
	ID_FUNCIONARIO SERIAL,
	NOME VARCHAR(255),
	IDADE INTEGER,
	FUNCAO VARCHAR(150),
	PRIMARY KEY(ID_FUNCIONARIO)
);

CREATE TABLE FUNCIONARIOS_LOG (
	COD_ALTERACAO SERIAL,
	USUARIO VARCHAR(150) NOT NULL,
	TIPO_ACAO VARCHAR(25) NOT NULL,
	DATA_ALTERACAO TIMESTAMP NOT NULL,
	PRIMARY KEY (COD_ALTERACAO)
);

Repare que na construção da tabela funcionarios eu não coloquei nenhuma regra de validação, como por exemplo not null, foi de propósito! Nossa trigger irá realizar a (simples) validação da entrada de dados na tabela e em seguida guardar que tipo de operação foi feita, por quem e a data na tabela funcionarios_log.

Agora a construção da stored function que será “chamada” pela trigger e sua agregação como trigger:

CREATE FUNCTION valida_dados_funcionario() RETURNS TRIGGER AS $valida_dados_funcionario$
BEGIN
	IF NEW.NOME IS NULL THEN
		RAISE EXCEPTION 'Por Favor, digite o nome do funcionario!';
	END IF;

	IF NEW.IDADE IS NULL THEN
		RAISE EXCEPTION 'Por favor, informe a idade!';
	END IF;

	IF NEW.IDADE < 0 THEN
		RAISE EXCEPTION 'Desculpe, o funcionario não pode ter % anos', NEW.IDADE;
	END IF;

	IF NEW.FUNCAO IS NULL THEN
		RAISE EXCEPTION 'Por favor, informe qual a função do funcinário!';
	END IF;

	-- Aqui iremos gravar no log o tipo de ação que foi realizada
	INSERT INTO FUNCIONARIOS_LOG (USUARIO, TIPO_ACAO, DATA_ALTERACAO) VALUES (CURRENT_USER, TG_OP, CURRENT_TIMESTAMP);

	RETURN NEW;
END;
$valida_dados_funcionario$
LANGUAGE plpgsql;

Note que realizei as devidas validações utilizando o operador NEW, porque agora iremos atrelar a trigger a tabela dizendo que ela será executada durante um insert ou update. Observe também que o declaramos um return “trigger” e especificamos os delimitadores $$, você pode encontrar mais informações sobre a estruturação de procedures de triggers na documentação do PostgreSQL, e por fim note que especificamos qual linguagem é utilizada para a construção da trigger, no caso plpgsql.

Veja abaixo como definimos a trigger, chamando a procedure que construímos anteriormente:

CREATE TRIGGER validacao_insert BEFORE INSERT OR UPDATE ON funcionarios
FOR EACH ROW EXECUTE PROCEDURE valida_dados_funcionario();

Pronto! Agora sua trigger já está funcionando nos eventos INSERT e UPDATE na tabela funcionario, faça os testes!

Agora para ilustrar ainda mais nosso exemplo irei alterar o nome da trigger, veja:

ALTER TRIGGER validacao_insert ON funcionarios RENAME TO a_validacao_insert

Para desabilitar (para habilitar troque o DISABLE por ENABLE) uma determinada trigger:

ALTER TABLE  funcionarios DISABLE TRIGGER a_validacao_insert

Ou para desabilitar todas as triggers de uma tabela:

ALTER TABLE  funcionarios DISABLE TRIGGER ALL

Agora, se eu desejar remover a trigger:

DROP TRIGGER a_validacao_insert ON funcionarios

Repare que não postei a imagem dos resultados para induzir você a testar o código! Faça os scripts de insert e update e veja as saídas produzidas pelo SGBD, acredito que você irá se divertir muito com os resultados!

Se você quiser saber mais sobre os triggers e sobre o PostgreSQL eu recomendo um livro (se você também for chegado a papel) que utilizei na minha monografia, intitulado PostgreSQL: Guia do Desenvolvedor, de André Milani.

Como você que leu (conseguiu chegar até aqui) triggers são um assunto muito extenso para se tratar aqui no blog, recomendo que você leia as referências e pesquisa mais sobre o assunto, é um tema muito interessante e útil para o dia a dia!

Referências:

• PostgreSQL Documentation – Triggers
• PostgreSQL Documentation – Trigger Procedures
• Wikibooks – PostgreSQL – Triggers
• iMasters – Triggers no PostgreSQL
• Ecoapre – Disparadores triggers en PostgreSQL (en espanhol)

Abraços,

Tiago.

Olá meus Leitores!

Estou disponibilizando para vocês o download da minha monografia, que apresentei para a obtenção do título de Tecnólogo em Informática para Gestão de Negócios pela Fatec Mococa em 2010.

Claro que o objetivo de eu estar colocando ela aqui é para consulta e pesquisa, nada de plágio porque nenhum professor é bobo ok?

O trabalho intitulado “E-business, uma abordagem sobre o business-to-business com o desenvolvimento de uma plataforma de negócios baseado na metodologias Web 2.0“, sob a orientação do Prof. MSc. Geraldo Henrique Neto.

Veja o resumo do trabalho:

Este estudo busca realizar uma investigação sobre o funcionamento da classe B2B
(Business-to-Business), termo contido no conceito de e-Business, que por sua vez
foi abordado em uma análise que teve por escopo identificar e expor termos como
e-ERP, e-CRM, e-SCM, e-Procurement, e-BI, e e-Commerce. Em seguida investigase
os impactos da implantação do e-Business na organização, com ênfase na classe
B2B, quando aborda-se ainda os aspectos envolvidos na terceirização da
implantação do conceito. E por fim, como componente da análise busca-se
desenvolver um modelo de plataforma B2B on-line, que sugere uma alternativa para
as interações entre empresas, ou seja, a empresa com seus fornecedores ou
parceiros, durante o desenvolvimento buscou-se utilizar metodologias de
desenvolvimento web 2.0, juntamente com alternativas open source, tais como PHP
(Hypertext Processor) e PostgreSQL.
Palavras-chave: e-Business. Business-to-Business. Modelo. Plataforma. Web 2.0.

Você pode fazer o download clicando aqui!

Espero que seja útil!

Abraços,

Tiago.

Meus Amigos!

Hoje é um dia de muita felicidade! Hoje meu nome estava entre os que foram aprovados para o Programa de Mestrado 2012 do Departamento de Computação da Universidade Federal de São Carlos!

Não tenho palavras para representar a alegria que sinto! Depois de tantas batalhas, paciência, estudo, ansiedade, enfim a recompensa! Irei fazer mestrado em Engenharia de Software, realmente estou muito feliz!

No momento em que soube pelo da minha aprovação pelo site do Departamento, e logo após minha vibração (!!!) liguei para todos os que me ajudaram e contribuíram para minha chegada até a UFSCar! Um abraço especial para Prof. Dr. Darlan Marcelo Delgado que foi o responsável pela minha iniciação científica, para o Prof. Dr. Jean Miler Scatena  que me orientou muito e forneceu cartas de recomendação, para o meu orientador nos tempos de monografia, Prof. MSc Geraldo Henrique Neto que aconselhou sobre a vida acadêmica e que sempre esteve presente quando precisei de cartas de recomendação e para o Prof. MSc. Fernando Duarte que me apoiou e me incentivou especialmente para o mestrado na UFSCar, também fornecendo cartas de recomendação. Meu muito obrigado a todos vocês e a todos os outros professores que fizeram parte até agora da minha trajetória acadêmica.

E claro não posso deixar de agradecer, do fundo do meu coração minha Mãe, Dona Helena, Meu Pai Sr Antônio e minha namorada Letícia que tanto me apoiaram na fase de estudos e seleção, além dos meus amigos mais próximos que sempre ouviram meus planos sobre a vida acadêmica, mais uma vez muito obrigado!

Realmente agora é um tempo de muita alegria, mas também de pensar em todo o trabalho de pesquisa que terei pela frente, e é claro ele também será postado aqui junto com o meu dia a dia na Universidade! Espero que todos que estejam acompanhando o blog apreciem essa minha nova empreitada e sorte a todos nós em 2012, que esse ano já vai se iniciar prometendo muito!

Muito obrigado a todos que estavam torcendo por mim!

Abraços,

Tiago.

Olá Amigos!

Estou inalgurando uma nova seção de posts aqui no blog, futuramente irei postar sobre a Zend Framework também! Ah Tiago, mas porque a Zend? Simples: Foi a Framework que eu mais me afeiçoei (confesso que ainda tenho uma queda pela Symphony, mas o que me impedirá de postar sobre ela no futuro também?), então aguardem que logo irei abordar ela por aqui também!

Acredito que ela será (e já é) um dos elementos chave para o fortalecimento (mais ainda) da comunidade PHP e para exaltar ainda mais a qualificação dos profissionais sérios da linguagem!

Os posts foram um dica do leitor @junin_feda quando falei sobre certificação, ele me indagou sobre a Zend, então decidi criar vergonha na cara de falar dela!

Separei aqui as vídeo aulas do Felipe Girotti que são muito boas mesmo! Já coloquei na ordem para facilitar, elas tem em torno de 20 minutos cada, vale muito a pena!

1. Introdução a Zend Framework com Zend Tool
2. Zend Framework Estrutura
3. Zend Layout
4. Conexão com Banco de Dados com a Zend Framework
5. Models na Zend Framewok I
6. Models na Zend Framewok II
7. Models na Zend Framewok III
8. Trabalhando com a Zend Db Select
9. Mapeamento de Relacionamentos com Zend I
10. Mapeamento de Relacionamentos com Zend II
11. Introdução ao Zend Forms
12. Zend Forms II (update em 28/12/2011)
13. Decorators (update em 15/01/2012)
14. Zend Forms III (Tradução) (update em 15/02/2012)

Infelizmente ainda não tenho nenhum conteúdo meu para postar aqui no blog sobre a Zend, mas em breve (esperam para Janeiro) irei postar algo!

Então é isso ai! Espero que as aulas do Felipe sejam tão úteis para vocês quanto foram para mim!

Abraços,

Tiago.

Olá Amigos!

Eu já estava estudando para a certificação PHP, em especial já estava lendo sobre as mudanças do PHP 5.3 e após a palestra do Klaus na PHP Conference 2011 me decidi a acelerar o processo para certificação.

Na verdade a certificação PHP já faz parte um plano da minha “lista de certificações” que também incluem Java e no futuro Oracle. Como os profissionais certificados são raros, em especial aqui no Brasil acredito que esse será um diferencial muito interessante para a minha carreira tanto no ramo acadêmico, quanto no ramo corporativo.

Pretendo realizar a prova no final de janeiro, e por enquanto, estou utilizando como meios de estudo o próprio Manual do PHP e os simulados (muito bons!) do site PHP Riot, e claro que pretendo acessar o material de estudo fornecido pela Zend.

Uma das dicas muito interessantes que vi na palestra do Klaus foi sobre o “decoreba” que foi deixado de lado na prova da nova certificação – 5.3 – agora temos que resolver problemas mais familiares do dia a dia. O que na minha opinião é mais acertivo (certifica os bons programadores) e até mais fácil de estudar.

Separei abaixo uma apresentação (in english) sobre os caminhos e dicas da certificação. Vale a pena dar uma olhada. E também encontrei posts muito interessantes no blog do Igor Escobar e do Fernando Mantoan que falam da experiência deles na obtenção da certificação.

Referências:

• Igor Escobar blog - Zend Certified Engineer, Vamos?
• Fernando Mantoan - Zend Certified Engineer PHP 5.3

Bem, agora é só estudar!

Abraços,

Tiago.

Bom revê-los caros leitores!

Hoje irei abordar um assunto bem batido, mas por uma óptica nova: a listagem de arquivos de um diretório através do PHP. Geralmente este recurso não é muito utilizado, mas para quem desenvolve o já desenvolveu sistemas mais robustos em PHP, já deve ter se deparado com essa necessidade, que antes era um pouco mais trabalhosa (que espaguetosa) pois tínhamos que utilizar de funções como readdir() e open_dir().

Felizmente, com a versão 5 do PHP veio a SPL (Standart PHP Library), que nada mais é que uma coleção de classes e interfaces que já abstrarem muita coisa que antes era braçal, e que agora fazem o “trabalho sujo”. Não é uma framework, e esá muito longe de ser rica como, por exemplo, o Java, mas já substitui grande parte das funções de array e no nosso caso o trabalho com diretórios.

Para exemplificar imagine que você precisa listar todos os arquivos de um diretório, e que ainda, dentro deste mesmo diretório existam subdiretórios e com arquivos dentro, e você deseja listar todos eles. Pois bem, você precisa fazer isso recursivamente, veja como fazer isso com a SPL:

$path = '/httpdocs/application/classes/';

$recursiveIterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));

foreach($recursiveIterator as $arquivo)
{
	echo $arquivo->getFilename(); // Aqui exibe o nome do arquivo corrente dentro do loop foreach

	/**
	 * Existem muito mais métodos que você pode chamar aqui dentro.
	 * por exemplo: getExtension(), getSize(), isExecutable(),
	 */
}

Simples não? Não? Calma eu explico: Na linha  a variável $path está definindo qual será o diretório que será lido, em seguida na linha 3 temos a declaração da classe RecursiveInteratorInterator, que recebe em seu construtor um objeto da classe RecursiveDirectoryIterator. Isso significa que estamos abrindo interações dentro dos diretórios, ou seja a cada passagem do loop foreach abaixo ele irá explorar um item do diretório, seja um arquivo ou um subdiretório.

Vale a pena a lida na documentação da classe para que você veja todos os métodos e propriedades disponíveis.

Referências:

• Manual PHP – Standart PHP Library – Classes
• Manual PHP – Standart PHP Library – Visão Geral
• Revista PHP – Standart PHP Library
• garotosopa – 7 coisas simples que alguns ainda complicam
• Codare – Percorrendo diretórios com SPL

Abraços,

Tiago.

diHITT – Notícias

Olá meus queridos!

Na semana passada eu abordei a questão dos índices no PostgreSQL, onde citei que eles podem estar dentro de um dado tablespace, pois bem, neste artigo irei abordar como funciona e para que você pode utilizar esse fantástico recurso do nosso querido Sistema Gerenciador de Banco de Dados – Postgres.

Você se lembra dos Schemas, que fazem a divisão lógica do banco? Pois bem, um tablespace faz a divisão física, isto é, podemos determinar onde os elementos do banco de dados – leia-se tabelas e índices – irão ficar. Mas como assim “irão ficar”? Simples: você pode definir um dado lugar no disco rígido, ou até mesmo outro disco!

Imagine que você tem um índice que é muito acessado e uma tabela que muito raramente é acessada, pois bem, você pode colocar esse índice em um disco SCSI e a tal tabela em um HD SATA comum, tendo em vista que o adaptador SCSI é muito veloz em comparação com o SATA. Fazendo isso você terá um ganho de desempenho muito significativo.

Veja abaixo as instruções SQL para a manipulação dos tablespaces.

Sintaxe para a criação de um tablespace:

CREATE TABLESPACE “hd_scsi” LOCATION '/mnt/seu_scsi'

Criar tabela dentro de um dado tablespace:

CREATE TABLE foo (
    id integer,
    nome varchar(150),
    primary key(id)
) TABLESPACE hd_scsi;

Veja como alterar um índice de tablespace:

SELECT ‘ALTER INDEX’, n.nspname AS schemaname , ‘.’ ,c.relname AS tablename, ‘SET TABLESPACE hd_scsi;’
FROM pg_class c
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
LEFT JOIN pg_tablespace t ON t.oid = c.reltablespace
LEFT JOIN pg_index x ON x.indexrelid = c.oid
WHERE c.relkind = ‘i’::”char”
AND x.indisprimary != ‘t’
AND x.indisunique != ‘t’
AND nspname NOT IN
(‘dbateste’,'information_schema’,'pg_catalog’,'pg_temp_1′,’pg_toast’,'postgres’,'publico’,'public’)
ORDER BY n.nspname

Veja como alterar uma tabela de tablespace:

SELECT 'ALTER TABLE' ,n.nspname AS schemaname,’.', c.relname AS tablename, ‘SET TABLESPACE hd_scsi;’
FROM pg_class c
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
LEFT JOIN pg_tablespace t ON t.oid = c.reltablespace
WHERE c.relkind = ‘r’::”char”
AND nspname NOT IN
(‘dbateste’,'information_schema’,'pg_catalog’,'pg_temp_1′,’pg_toast’,'postgres’,'publico’,'public’)
ORDER BY n.nspname

Referências:

• Kenia Milene G.’s Blog - Alterando Tablespace de Tabelas e Indices no PostgreSQL
• PostgreSQL Manuals – Tablespaces
• PostgreSQL BR – Tablespaces no PostgreSQL
• Devmedia – Tablespace

Semana que vem irei abordar o funcionamento das triggers!

Abraços,

Tiago.