Algumas vezes eu me deparei com o problema de retornar mais de um resultado com uma função, um conjunto de resultados, e o Postgres nos favorece com alguns artifícios para tal. De fato não são exatamente muito simples de se manejar, mas também não é um bicho de sete cabeças. Tal como fizemos quando manipulamos triggers, aqui iremos utilizar a linguagem PL/pgSQL para construirmos nosso trabalho, que consistirá em quatro maneiras. Outra informação importante é que enquanto eu escrevia esse post estava usando a versão 8.3 para realizar os testes nos códigos.

Eu encontrei duas  maneiras de executar esse trabalho, e após compartilhar o post no grupo PostgreSQL  Brasil no LinkedIn, o Fabrízio que orientou mais duas maneiras que veremos a seguir, e se você souber de mais alguma sinta-se livre para contribuir, por exemplo, enquanto eu estava escrevendo a primeira versão minha doce namorada Bruna me deu várias luzes. Bom mas abordando o nosso tema, inicialmente tomemos vejamos as seguintes linhas de código que representam a tabela que será a base das nossas consultas:

CREATE TABLE pessoa_fisica (
	id_pessoa SERIAL,
	nome VARCHAR(80),
	sobrenome VARCHAR(200),
	sexo CHAR(1),
	cpf CHAR(11),
	PRIMARY KEY(id_pessoa)
);

Agora vamos aos métodos de retorno dos dados que estão dentro desta tabela (presumo que você tenha abastecido ela), como mencionei vou abordar quatro maneiras.

1) Tipo retorno RECORD

Um tipo “genérico”, bem mais comum nas buscas na internet, este é o tipo mais comentado, mas existe um empecilho, o qual é necessário especificar as colunas que iremos resgatar quando chamarmos a função, veja o código abaixo na linha 8:

CREATE FUNCTION blog_get_pessoas() RETURNS SETOF RECORD AS $$
BEGIN
	RETURN QUERY SELECT id_pessoa, nome, sobrenome, sexo, cpf FROM pessoa_fisica;
	RETURN;
END;
$$ LANGUAGE 'plpgsql';

SELECT * FROM blog_get_pessoas() AS (id_pessoa INTEGER, nome VARCHAR, sobrenome VARCHAR, sexo CHAR, cpf CHAR)

Veja que quando defini o tipo de retorno da função eu determinei dois parâmetros, SETOF que indica que a função irá retornar um conjunto de itens, ao invés de um único item e RECORD que está me dizendo que o retorno será um conjunto de resultados. Perceba que utilizei a instrução RETURN QUERY e logo após um SELECT tradicional para “capturar” os dados, o RETURN QUERY foi introduzido no Postgres na versão 8.3.

Observe que a instrução RETURN (sozinha, na linha 4) é que irá realizar o retorno do nosso conjunto. Agora note a forma estranha que chamamos a função, como se fosse uma tabela realizamos o select e em seguida empreendemos um “alias” especificando quais campos vieram na query realizada (estranho, não?), enfim se você não colocar todos os campos, conforme a query que foi realizada na função, haverá problemas.

2) Retornando os campos de uma dada Tabela

Agora se os dados de retorno da sua função forem oriundos de apenas uma tabela, você pode setar o tipo de retorno como sendo exatamente o da tabela trabalhada, veja que no nosso exemplo que coloquei pessoa_fisica, como o tipo de retorno:

CREATE FUNCTION blog_get_pessoas2() RETURNS SETOF pessoa_fisica AS $$
BEGIN
	RETURN QUERY SELECT * FROM pessoa_fisica
	RETURN;
END;
$$ LANGUAGE 'plpgsql'

SELECT * FROM blog_get_pessoas2();

Aqui temos como retorno possível todos os campos da nossa tabela de teste, no caso pessoa_fisica, claro que ao chamar a função você poderia selecionar os campos que vão lhe interessar. Repare que ao contrário do primeiro exemplo não precisamos especificar quais campos eventualmente viriam na query, essa na minha opinião é uma das maneiras mais práticas, mas ai vai da sua necessidade.

3) Tipo de retorno RETUNS TABLE

Apensar de eu não conseguir testar o RETURNS TABLE (porque a versão 8.3 ainda não suportava esse recurso) ela existe, veja aqui na documentação oficial do Postgres. Dê uma olhada de como ficaria o código da nossa função:

CREATE FUNCTION blog_get_pessoas3() RETURNS TABLE (id_pessoa INT,
						   nome VARCHAR,
						   sobrenome VARCHAR,
						   sexo CHAR,
						   cpf CHAR) AS $$
BEGIN
	RETURN QUERY SELECT * FROM pessoa_fisica;
	RETURN;
END;
$$ LANGUAGE 'plpgsql'

SELECT * FROM blog_get_pessoas3();

Repare que declaramos os atributos, que serão os “nomes de coluna” quando chamarmos nossa função. É muito útil quando vamos retornar dados de mais de uma tabela, ao contrário de tudo que já vimos anteriormente, dessa maneira podemos expressar no corpo da função, explicitamente, quais serão as tuplas no retorno. Uma observação importante: repare que na linha 7 eu estou selecionando todos os campos, você deve atentar-se para que todos os campos coincidam com os determinados no tipo de retorno.

4) Criando um tipo específico de retorno, o CREATE TYPE

Já a quarta opção, é que criamos o tipo de retorno da função “personalizado”, exatamente como nesta instrução:

CREATE TYPE type_pessoa_fisica AS (
	id_pessoa INT,
	nome VARCHAR,
	sobrenome VARCHAR,
	sexo CHAR,
	cpf CHAR
);

Repare que a instrução CREATE TYPE é bem semelhante a instrução para criação de tabelas, com ela é possivel criar um “mix” de duas tabelas por exemplo, ai vai da sua imaginação, aqui no meu exemplo ficou bem simples, mas agora que vem a parte interessante, veja como ficou a nossa função:

CREATE FUNCTION blog_get_pessoas4() RETURNS SETOF type_pessoa_fisica AS $$
DECLARE
	dados_pessoa type_pessoa_fisica;
BEGIN
	FOR dados_pessoa IN SELECT id_pessoa, nome, sobrenome, sexo, cpf  FROM pessoa_fisica LOOP
		RETURN NEXT dados_pessoa;
	END LOOP;
	RETURN;
END;
$$ LANGUAGE 'plpgsql'

SELECT * FROM blog_get_pessoas4();

A primeira coisa que notamos a ler é o tipo de retorno da função, o type_pessoa_fisica que já especifica quais os campos que serão retornados, posteriormente temos o DECLARE onde construimos uma variável chamada dados_pessoa que irá conter o conteudo da nossa query, note que tem o mesmo tipo de retorno da função, exatamente porque é esta variável que vamos retornar. Em seguida, para abastecer a nossa variável com os registros da tabela temos a instrução FOR-IN-SELECT que é m looping que a cada iteração “coloca uma linha na variável”, repare que a instrução RETURN NEXT é que “abastece” nossa variável, e apesar de ser um “RETURN” não encerra a execução do código naquele instante, note que há a instrução RETURN após o fim do loop (END LOOP), esta sim irá terminar a função.

E na linha 12 temos a chamada da função, bem mais amigável que em comparação com o experimento 1, e é (quase) exatamente como a chamada de uma tabela, lá você pode introduzir as clausulas WHERE e LIMIT por exemplo.

Espero que tenham gostado! Façam os testes e não deixem de comentar, e conheça também a fã page do blog no Facebook.

Referências:

• PostgreSQL Documentation – Create Function
• WikiBooks – Funções em PL/pgSQL
• PostgreSQL Brasil – Retornando registros de consultas genéricas com RETURN QUERY

Abraços,

Tiago.

Ainda estudando frenecamente para o mestrado na UFSCar, hoje eu trago para vocês uma dica que vi no Facebook do meu ex-Prof Avelino Pimenta, ele postou o link de algumas vídeo aulas do Kretcheu, eu dei uma conferida nelas e digo que me ajudaram muito com a minha matéria de redes.

As vídeo aulas são bem explicativas e vão falar sobre protocolos das redes, ip, máscara de rede e gateway, apesar de serem muito boas são bem curtinhas, totalizando quase uma hora de aula, e mais, aconselho você a dar uma olhada no canal do YouTube que está repleto de material sobre software livre e derivados, vale a pena

Abaixo estão dos vídeos, na ordem que eu vi, espero que gostem:

Em seguida, veja este:

Abraços,

Tiago.

Prazer em revê-los novamente aqui no blog, e inicialmente eu gostaria de agradecer a audiência que vem crescendo a cada mês! Já estamos indo para 7 meses de blog e meus posts sobre o PostgreSQL estão sendo bem recebidos pela comunidade! Meu muito obrigado a vocês que fazem o blog acontecer!

Tratando agora do nosso assunto, em um post anterior sobre a utilização do operador iLIKE eu mencionei a particularidade do Postgres em realizar buscas discernindo os caracteres upper-case de low-case, no entanto há também a possibilidade de inserir expressões regulares a fim de refinar a busca, e para tal utilizamos o operador Similar To.

Para ilustrar o funcionamento desse operador, tome como base este problema: “Recuperar o nome das pessoas que terminam em “Silva” ou “Souza”. Aqui vocês irão me dizer que poderíamos utilizar os operados que já conhecemos como o LIKE e o iLIKE, e claro que sim, poderíamos e inclusive eu fiz algumas comparações com o desempenho, veja só:

SELECT * FROM pessoas WHERE sobrenome LIKE '%SILVA' OR sobrenome LIKE '%SOUZA' -- Gastou 150 ms com 1961 resultados
SELECT * FROM pessoas WHERE sobrenome iLIKE '%silva' OR sobrenome iLIKE '%souza' -- Gastou 250 ms com 1961 resultados
SELECT * FROM pessoas WHERE sobrenome SIMILAR TO '(%SILVA|%SOUZA)' -- Gastou 350 ms com 1961 resultados
SELECT * FROM pessoas WHERE sobrenome SIMILAR TO '%(SILVA|SOUZA)' -- Gastou 300 ms com 1961 resultados

Pelo menos aqui nos meus testes o Similar To se mostrou o operador mais lento, apesar de não existir nenhuma referência sobre o desempenho dele no manual. Por natureza isso se deve acontecer porque ele mescla o funcionamento dos outros operadores testados com a implementação e expressões regulares POSIX. Eu não encontrei uma maneira de fazer o Similar To funcionar como o iLIKE, então se alguém tiver alguma sugestão sinta-se livre para comentar =)

Listei aqui abaixo os artivicios que você utlilizar para realizar junto com o Similar To como está no manual do Postgres:

• | representa alternância (uma das duas alternativas).
• * representa a repetição do item anterior zero ou mais vezes.
• + representa a repetição do item anterior uma ou mais vezes.
• Os parênteses () podem ser utilizados para agrupar itens em um único item lógico.
• A expressão de colchetes [...] especifica uma classe de caracteres, do mesmo modo que na expressão regular POSIX.

Seria muito interessante você dar uma lida no Manual do Postgres, lá você irá encontrar material mais completo, nas referências abaixo você tem o link que está em inglês, se preferir aqui está a versão em português, só que da versão 8.0 (apensar da versão em inglês não mudar muita coisa).

Referências:

• PostgreSQL Documentation –  Parttern Matching
• Network Theory – Similar To Regular Expressions

Abraços,

Tiago.

Acho que vocês já estão acostumados com a minha ausência aqui então vamos ao que interessa! Ontem (01/03) foi liberado o PHP 5.4 e hoje estou aqui para comentar um pouco das novas funcionalidades, como a nova maneira de declarar um array, traits e um console para rodar códigos PHP diretamente!

Novidades nos Arrays

Quem geralmente trabalha com JavaScript estava acostumado a uma declaração mais curta, usando os [], assim eu peguei emprestado um exemplo do manual do PHP, dê uma olhada como é possível declarar arrays agora:

<?php

// Antes tinha que ser assim:
$array = array(
    "foo" => "bar",
    "bar" => "foo"
);

// Agora pode ser assim também!
$array = [
    "foo" => "bar",
    "bar" => "foo"
];
?>

E além da nova forma de declaração também foi implementado a Array Deferencing que em outras palavras é o acesso direito de um membro do array diretamente no retorno de um método/função caso este retorne um array:

<?php
function getArray() {
    return array(1, 2, 3);
}

// Como podemos fazer agora
$secondElement = getArray()[1];

// Como fazíamos "antigamente"
$tmp = getArray();
$secondElement = $tmp[1];

// ou assim
list(, $secondElement) = getArray();
?>

Bacana não é? isso vai deixar o código mais limpo e a programação mais divertida (saudades do meu tempo de programação PHP hehe).

Traits

E agora para deixar mais interessante, na versão 5.4 o PHP passa a implementar Traits, que aparecem para suprir aquelas problemas que você acredita  que seriam possíveis de resolver com herança múltipla no PHP, o que os Traits fazem é uma herança horizontal, sugiro que você dê uma lida no post do Hélio sobre isso, lá ele explicou de maneira muito proveitosa. Em todo caso abaixo você vê um exemplo da implementação deles no PHP, o exemplo foi tirado do Manual do PHP:

<?php
class Base {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'World!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello(); // Exibirá "Hello World"
?>

Build-in Web Server 

Agora o PHP implementa nativamente no seu núcleo um web server que você pode acessar via linha de comando no Linux, Windows e Mac. Dê uma olhada na documentação oficial dele aqui.

Melhorias Acrescentadas

• Informações sobre Progresso de Upload em variável $_SESSION (até que enfim!!)
• Adição de tipo de número binários
• Suporte para sintaxe Class::{expressão}()
• Short open tags <? agora são suportadas sem necessidade de alterar o arquivo ini
• Otimização do consumo de memória

Funcionalidades Removidas

• Register_globals, safe_mode e magic_quotes removidos.
• y2k_compliance no arquivo ini
• Funções de sessão: session_is_registered(), session_register() e session_unregister()
• Extensão do sqlite agora está no PECL

Bugs Resolvidos

• #60879 unserialize() não chama  __wakeup() do objeto).
• Correção da incompatibilidade de binários com PDO
•  #48877  “bindValue” e “bindParam” agora funcionam para o PDO Firebird
• #55801 Comportamento de unserialize() mudou para melhorar performance

Se você quiser ver toda a lista de novas funcionalidades e bugs resolvidos, olhe neste link.

Bom gente, esse foi meu simples review sobre os novos atributos da nossa querida linguagem, espero que vocês tenham gostado, e deem uma olhada na página oficial do PHP, lá vocês poderão encontrar informações e muitos mais exemplos no manual da linguagem.

Referências:

• Manual do PHP – Arrays
• Manual do PHP – Traits
• Manual do PHP – Build-in Web Server
• hlegius - Traits em PHP – herança horizontal
• 4Linux - Webcast Tutorial: Sobre o PHP 5.4 e o futuro
• Duodraco - PHP 5.4 – saiba o que vem por aí

Abraços,

Tiago.

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.