Para começar, caso você utilize um campo de texto no Mysql como VARCHAR, TEXT, etc, na hora de fazer uma consulta ele não considerará se seu texto comparado está exatamente igual ao texto da comparação quando falamos em Maiúsculas/Minúsculas. Então para resolver isso, devemos fazer um casting na comparação utilizando o operador BINARY do Mysql. De longe essa é a alternativa mais simples que eu encontrei, existem outras, que envolvem mudar o COLLATE durante a consulta, mas não me pareceu elegante nem muito promissor.

A função do operador BINARY é muito simples, ele transforma todo o texto passado pra ele em código binário, logo “x” em binário é totalmente diferente de “X”. Abaixo alguns exemplos:

    SELECT "x" = "X";
    retorna 1
    SELECT binary "x" = "X"
    retorna 0

É claro que além dessa comparação simples ele é aceito na comparação LIKE:

    SELECT binary "xorna" LIKE "%X%"
    retorna 0
    SELECT binary "Xorna" LIKE "%X%"
    retorna 1

É simples, funciona, eu diria que isso é um workaround elegante (se é que existe isso).

<?php
/**
 * Classe para manipulação de diretórios
 * Exclusivo para uso em sistemas Unix Like
 * Sem vontade para portar para plataforma MS
 * @author André Gustavo Espeiorin
 * @version 1.0
 * @package X
 */
class X_Dir
{
	/**
	 * Metodo Responsavel pela criação de diretórios
	 * @param $location - onde a pasta deve ser criada
	 * @param $name - nome da mesma, evite o uso de caracteres especiais e espaços em branco
	 * @param $chmod - permissão para o acesso a nova pasta
	 * @param $recursive - criar recursivamente?
	 * @return <string> caminho da pasta criada
	 */
	public static function create($location, $name, $chmod=0777, $recursive=true)
	{
		$path = $location . $name;
		/**
		 * Supressão de erro não aconselhada, porém caso a pasta exista
		 * o PHP lançará um aviso, coisa que nao queremos caso haja
		 * redirecionamento após a criação da mesma
		 */
		if( @mkdir( $path, $chmod, $recursive ) ){
			chmod( $path, $chmod );
			return $path . '/';
		} else{
			if( is_writable($path) && is_readable($path) ){
				return $path;
			}else{
				echo 'erro';
			}
		}
	}

	/**
	 * Método criado para apagar um arquivo unicamente, e não um diretório
	 * Pode apagar arquivos e links simbólicos
	 * @param $fileName - Nome do arquivo
	 * @return <boolean>
	 */
	public static function removeFile($fileName)
	{
		if ( is_file($fileName) || is_link($fileName) ) {
        	return unlink($fileName);
    	}else{
    		return false;
    	}
	}

	/**
	 * Método responável por remover um diretório, é capaz de remover
	 * um diretório completo, incluindo subdiretórios e arquivos por meio
	 * da recursividade.
	 * @param $dirname - nome do diretório como seu caminho completo no Sistema de Arquvios
	 * @return <boolean>
	 */
	public static function remove($dirname)
	{
		// Checa se existe o diretório
    	if ( !file_exists($dirname) ) {
        	return false;
    	}

    	/**
    	 * Caso encontrar um arquivo em meio a recursividade, ele o removerá
    	 * tratando ele como um arquivo e não diretório
    	 */
    	if (is_file($dirname) || is_link($dirname)) {
        	return self::removeFile($dirname);
    	}

    	/**
    	 * Abre o diretório chamado como um objeto dir
    	 * Faz a iteração no mesmo, lendo seu interior
    	 * e chamando recursivamente o mesmo até eliminar
    	 * todo o conteúdo do diretório
    	 * @var <object> diretório
    	 */
    	$dir = dir($dirname);
   		while (false !== $entry = $dir->read()) {
        	// Pula os ponteiros
        	if ($entry == '.' || $entry == '..') {
          	  continue;
        	}
        	// Chama novamente a função
    	    self::remove( $dirname . DIRECTORY_SEPARATOR . $entry );
    	}
    	// Fechamos nosso objeto dir
   		$dir->close();
   		// Finalmente remove nosso diretório
    	return rmdir($dirname);
	}

	/**
	 * Este método é utilizado na necessidade de renomear um diretório
	 * Utiliza recursividade para sub-diretórios e funcionou muito
	 * bem em todos os testes
	 * @param $path - Caminho até a localização do diretório a ser renomeado
	 * @param $oldDir - Nome do diretório a ser renomeado
	 * @param $newDir - Novo Nome para o diretório
	 * @return <boolean>
	 */
	public static function rename($path, $oldDir, $newDir)
	{
		// Checa se o diretório existe
    	if (!file_exists($path . $oldDir)) {
        	return false;
    	}   	

    	// Cria o novo diretório
    	$new = self::create($path, $newDir);

    	/**
    	 * Abre o velho diretório e itera ele, transferindo todos os arquivos para o novo
    	 * Os subdiretórios são transferidos do mesmo modo, por meio de recursividade
    	 * @var <object> dir
    	 */
    	$dir = dir($path . $oldDir);
   		while (false !== $entry = $dir->read()) {
        	// Pula os Ponteiros
        	if ($entry == '.' || $entry == '..') {
          	  continue;
        	}
        	// Se o conteudo for um diretório, recursividade!
        	if( is_dir($new . $entry) ){
        		self::rename($path . $oldDir, $entry, $path . $new . $entry );
        	}
        	// Aqui é feita a transferencia de arquivos
        	rename( $path . $oldDir . '/' . $entry, $new . $entry );
    	}
    	// Fecha o objeto
   		$dir->close();
   		// Remove o diretório antigo
   		self::remove( $path . $oldDir );
   		return true;
	}
}

Aqui vai um pequenino exemplo de como isso pode facilitar sua vida:

# vamos criar um diretório
echo X_Dir::create('/var/www/arigos/', 'aaa');
# agora outro dele
echo X_Dir::create('/var/www/arigos/aaa/', 'qwe1');
# antes do próximo passo, crie vários arquivos dentro das pastas... algo como:
$ touch aaa/teste.wtf
$ touch aaa/teste.sql
$ touch aaa/teste.php
$ touch aaa/qwe1/teste.php
$ touch aaa/qwe1/teste.asd
$ touch aaa/qwe1/teste.123
# agora renomeamos a pasta pai
echo X_Dir::rename('/var/www/arigos/', 'aaa', 'bbb');
# removemos um unico arquivo
echo X_Dir::removeFile('/var/www/arigos/bbb/qwe1/teste.123');
# e apagamos por completo tudo!
echo X_Dir::remove('/var/www/arigos/bbb/');

Muito simples, os “echos” que estão aí são somente para ver o que ta retornando, pois agora sua obrigação é testar se ta criando, renomenando e apagando…

<?php
/**
 * Classe para busca de dados de geolocalização
 * utiliza um webservice gratuito do iplocationtools.com
 * utilizando o formato json como padrão, por ser mais leve e ágil para tratar
 * @author André Gustavo Espeiorin <andregustavodocaqui@gmail.com>
 * @version 1.0
 * @package X
 *
 */
class X_Location
{
	/**
	 * Formato Padrão
	 * @var <string>
	 * @access private
	 */
	private $_format = 'json';

	/**
	 * Endereço inicial para a pesquisa
	 * @var <string>
	 * @access private
	 */
	private $_queryUrl = 'http://iplocationtools.com/ip_query.php?ip=';

	/**
	 * Objecto de consulta do CURLs
	 * @var <object>
         * @access private
	 */
	private $_ch;

	/**
	 * Dados tratados
	 * @var <array>
	 * @access private
	 */
	private $_data;

	/**
	 * Construtor da Classe, recebe o parrametro <string> format
	 * Caso o paramêtro não seja passado, usa o padrão do sistema
	 * @return <void>
	 */
	public function __construct()
	{
		$this->_ch = curl_init();
	}

	/**
	 * Método que faz a consulta e tratamento dos dados, recebe o ip
	 * a ser consultado como parâmetro
	 * @param $ip
	 * @return <boolean>
	 */
	public function getData($ip)
	{
		if( isset($ip) && !empty($ip) ){
			curl_setopt($this->_ch, CURLOPT_URL, $this->_queryUrl . $ip . '&output=' . $this->_format);
			curl_setopt($this->_ch, CURLOPT_RETURNTRANSFER, 1);
			curl_setopt($this->_ch, CURLOPT_TIMEOUT, 15);

			$request = curl_exec($this->_ch);
			if( isset($request) && !empty($request) ){
				$this->_data = json_decode($request, true);
				return true;
			} else{
				return false;
			}
		} else{
			return false;
		}
	}

	/**
	 * Método utilizado para pegar os dados de _data, caso o keyName seja ignorado, retorna o array inteiro
	 * Aqui eu listo as chaves que podem ser buscadas:
	 * -Ip
	 * -Status
	 * -CountryCode
	 * -CountryName
	 * -RegionCode
	 * -RegionName
	 * -City
	 * -ZipPostalCode
	 * -Latitude
	 * -Longitude
	 * @param $paramName
	 * @return <array> | <string>
	 */
	public function get($keyName='')
	{
		if( isset($keyName) && !empty($keyName) ){
			return $this->_data[$keyName];
		}else{
			return $this->_data;
		}
	}

}

Show, se a classe parece simples, imagine seu uso, abaixo pequeno exemplo:

$gl = new X_Location();
$gl->getData('seuIp');
echo $gl->get('City');
// ou
var_dump($gl->get());

Bom, espero que seja útil a todos, agradeço sua visita!

Para baixa o Doctrine ORM é muito simples, basta acessar a página de download oficial, e selecionar a versão desejada, eu aconselho a baixar a última versão stable (atualmente 1.1.0). Após o download, descompacte o arquivo, para o uso em produção você vai precisar somente da pasta lib e de seu conteúdo é claro, tomando como exemplo o ubuntu, vamos criar uma aplicação chamada doctrineTest em /var/www (com as devidas permissões de escrita na pasta):

$ cd /var/www
$ mkdir doctrineTest
# vá até a pasta Dotrine-1.x.x
$ cp -R lib /var/www/doctrineTest
# aproveita e cria o index.php
$ touch index.php
# vamos criar uma classe para autoload
$ cd /var/www/lib
$ mkdir Util
$ touch Autoload.class.php

Justo, agora já temos o inicio de nossa aplicação salva no diretório de site do apache, vamos começar a configuração e a entender tudo isso. Abra seu editor preferido (eclipse no meu caso), abra o arquivo lib/util/autoload.class.php, vamos fazer um pequeno truque para nos livrarmos dos includes.

class Util_Autoload
{
    public function autoload($class)
    {
        $path = str_replace('_', '/', $class) . '.php';
        require_once($path);
        return true;
    }
}

Feito isso, vamos ao nosso index.php, primeiro vamos configurar nosso autoload

/* Adicionando a pasta libs ao include_path do php */
$include_path  = get_include_path();
$include_path .= PATH_SEPARATOR . dirname(__FILE__) . '/lib';
set_include_path($include_path);
unset($include_path);

/* registrando nossa classe autoload */
require_once(dirname(__FILE__) . '/lib/Util/Autoload.class.php');
spl_autoload_register(array('Util_Autoload', 'autoload'));

Legal, a essa altura qualquer classe que quisermos carregar dentro de libs estará disponível, agora vamos abrir nossa primeira conexão com o banco de dados (no exemplo MySQL):

$dsn = 'mysql://username:password@127.0.0.1/doctrineTest';
$manager = Doctrine_Manager::getInstance();
$conn = $manager->connection($dsn, 'master');

Bom, agora já conseguimos conectar a aplicação com o banco de dados, para finalizarmos este capitulo vamos fazer um pequeno teste de conexão, certifique-se que o usuário no qual você está conectando tenha permissões de CREATE no banco de dados. Vamos criar uma tabela e depois inserir dados nela:

$conn->export->createTable('teste', array('nome' => array('type' => 'string')));
$conn->execute('INSERT INTO teste (nome) VALUES (?)', array('blogdoxorna'));

Legal, tabela criada, uma linha inserida, agora vamos ler pra ver se é verdade que tá gravando (claro, comentando a linha do create pra não dar pau!)

$st = $conn->prepare('SELECT * FROM teste');
$st->execute();
$resultset = $st->fetchAll();
var_dump($resultset);

O que deve aparecer aí no browser é mais ou menos isso:

array
  0 =>
    array
      'nome' => string 'blogdoxorna' (length=11)
      0 => string 'blogdoxorna' (length=11)

Bom, encerro aqui o meu post, e lembrando que se eu sair vivo do #NOB #TwitteirosDeJoinville no Biergarten, eu posto a terceira parte ainda hoje 29/04 a noite

O que é Dotrine ORM?

O Doctrine ORM, como seu próprio nome diz, é uma ferramenta de ORM (Object-relational mapping) ou no bom e velho pt-br: Mapeamento Objeto-Relacional. Foi concebida sob a licensa GNU Lesser General Public License. Suas principais influências foram o Hibernate(Java) e o ActiveRecord(Rails). Atualmente se encontra na versão 1.1.0 (estável) e é compatível com PHP 5.2.3+ pois o mesmo utiliza a biblioteca PDO.

Mas o que exatamente esse tal de Doctrine ORM faz?

Sua função simplificando, é reduzir a impedância do uso de Banco de Dados Relacionais e Sistemas Orientados a Objetos. Ele utiliza o Design Pattern Active Record para fazer abstração entre as tabelas do banco de dados e as suas respectivas classes, ou seja, para cada tabela no banco teremos uma classe correspondente. Sendo possível delegar a responsabilidade da criação das classes para o doctrine, mas isso é um outro assunto.

Legal, e tem mais? – Muito Mais…

Inspirado no HQL (Hibernate) foi criado o DQL (Doctrine Query Language) que eu acho muito bom, facilita muito na hora de criarmos consultas enxutas ou que tenham relacionamentos a serem pesquisados. Além disso há também a possibilidade de executar consultas com SQL nativo, mas é desencorajado, visto que uma parte do seu problema antes de usá-lo são justamente consultas com SQL nativos.

Fale-me mais Xorna, e é fácil para se achar? aprender mais? – É claro!!

Ele possuí uma boa documentação, com bastantes artigos, e uma comunidade de usuários que tende a crescer visto sua facilidade de acoplamento com frameworks populares. No próximo post daremos o ponta pé inicial em nossos estudos, mostrarei a instalação, estrutura de diretórios e começaremos nosso primeiro exemplo.

Consulta simples, como um SELECT * FROM `users`

$select = new Zend_Db_Select();

$select->from(?users?);

$rs = $select->query();

$data = $rs->fetchAll();

Consulta com inserção de clausula WHERE, como um SELECT * FROM `users` WHERE `id` > 10:

$select = new Zend_Db_Select();

$select->from(?users?);

$select->where(?id > ??, 10);

$rs = $select->query();

$data = $rs->fetchAll();

· Consulta com seleção de campos e cláusula WHERE, como um SELECT id, name FROM `users` WHERE id > 10:

$select = new Zend_Db_Select();

$select->from(?users?);

$select->columns(?id, name?);

$select->where(?id > ??, 10);

$rs = $select->query();

$data = $rs->fetchAll();

· Consulta com seleção de campos e cláusula WHERE e INNER JOIN, como um SELECT `users`.`id`, `users`.`name`, `pictures`.`address` FROM `users` INNER JOIN `pictures` ON `pictures`.`user_id` = `users`.`id` WHERE id > 10;

$select = new Zend_Db_Select();

$select->from(?users?);

$select->columns(?users.id, users.name, pictures.address?);

$select->joinInner(?picures?, ?picures.user_id = user.id?);

$select->where(?id > ??, 10);

$rs = $select->query();

$data = $rs->fetchAll();

Além dos métodos utilizados acima a api da classe na qual o Drimio_Db_Select extende em http://framework.zend.com/apidoc/core/Zend_Db/Select/Zend_Db_Select.html

No seu arquivo de bootstrap, após criar a sua conexão com o banco de dados, você deverá criar um profile e defini-lo como o profiler daquelas conexão:

$connection = Zend_Db::factory($adapter, $config);$profiler = new Zend_Db_Profiler_Firebug('All DB Queries');

$profiler->setEnabled(true);

$connection->setProfiler($profiler);

Após isso, basta ter o firebug e o firephp ativados para conferir o profiling de suas consultas no console do firebug.

Crie um diretório com um nome qualquer (ao alcance do bootstrap), eu chamei ele de cache, e insira o seguinte código ao seu bootstrap:

$classFileIncCache = {caminho da pasta cache} . 'pluginLoaderCache.php';
if( file_exists($classFileIncCache) ){
	include_once $classFileIncCache;
}
Zend_Loader_PluginLoader::setIncludeFileCache($classFileIncCache);

Após isso o Zend mesmo irá tomar conta de criar o arquivo pluginLoaderCache.php para você e inserir o conteúdo. Não se esqueça de dar permissão de escrita na pasta cache.

A implementação é muito simples, você terá apenas que criar uma classe e mudar o modo que cria sua sessão, o resto permanece igual, pois é Zend_Session se encarrega de achar a sessão dentro do cache. Abaixo vai o código da nova classe que deve implementar a interface Zend_Session_SaveHandler_Interface.

class Xorna_SessionHandler implements Zend_Session_SaveHandler_Interface{

private $maxlifetime = 3600;

public $cache = '';	public function __construct($cacheHandler) {

$this->cache = $cacheHandler;

}

public function open($save_path, $name) {

return true;

}

public function close() {

return true;

}

public function read($id) {

if(!($data = $this->cache->load($id))) {

return '';

}

else {

return $data;

}

}

public function write($id, $sessionData) {

$this->cache->save($sessionData, $id, array(), $this->maxlifetime);

return true;

}

public function destroy($id) {

$this->cache->remove($id);

return true;

}

public function gc($notusedformemcache) {

return true;

}

}

?>

Bom, feito isso agora só precisamos instanciar isso, e criar a sessão:

Zend_Loader::loadClass('Xorna_SessionHandler');

$cache = Zend_Cache::factory('Core', 'Memcached', $frontendOptions, $backendOptions);

Zend_Session::setSaveHandler(new Xorna_SessionHandler($_cache));

Zend_Session::start();

Daqui em diante nada muda.

Primeiramente vamos falar sobre o memcache, ele é um daemon, ou seja, um serviço que roda stand-alone na máquina, que utiliza uma ou mais portas, e que pode ser inicializado, parado e reinicializado conforme necessidades. Ao contrário da sessão do PHP, que é visível somente dentro do escopo de acesso do usuário (claro que existem maneira de compartilhar sessões), o memcache é visível dentro de toda aplicação, ou seja, se tivermos 100 usuários on-line, eles compartilharão o mesmo cache. O motivo pelo qual cheguei ao uso do memcache é a necessidade diária de ganhar performance mantendo a qualidade do sistema mantendo todas as suas funcionalidades, mas vamos parar por aqui e vamos colocar a mão na massa.

Instalação

• Baixe os binários do memcache no site http://code.jellycan.com/memcached/ (pegue os binários win32).
• Agora vamos à instalção propriamente dita:
• Descompacte o conteúdo do arquivo onde desejar (eu usei c:memcache), você deverá ter os seguintes arquivos dentro da pasta:
• memcache.exe
• msvcr1.dll
• Abra o terminal do windows =P
• Instale o memcache com o seguinte comando: c:memcachememcache.exe -d install
• Inicialize o serviço com o seguinte comando: c:memcachememcache.exe -d start

Agora com o memcache instalado e iniciado, vamos a configuração do WAMP Server, antes de mais nada é preciso fazer o download da dll do memcache para windows neste endereço: http://pecl4win.php.net/ext.php/php_memcache.dll. Feito isso vai la em c:wampinphpphp5.2.5ext e cole essa dll dentro, feche o WAMP, inicie-o novamente, clique com o botão esquerdo no icone do wamp > php > php extensions > habilite a extensão memcache. Pronto, agora é só fazer um teste com o script postado abaixo e está tudo certo.

// Exemplo extraído do site www.php.net

$memcache = new Memcache;

$memcache->connect("localhost",11211);echo "Server's version: " . $memcache->getVersion() . "n";

$tmp_object = new stdClass;

$tmp_object->str_attr = "test";

$tmp_object->int_attr = 123;

$memcache->set("key",$tmp_object,false,10);

echo "Store data in the cache (data will expire in 10 seconds)n";

echo "Data from the cache:n";

var_dump($memcache->get("key"));

?>

Após isso, está funcionando, mas temos um porém nessa história, por padrão o memcache utiliza o tamanho máximo de cache de 64mb, então caso queira aumentar essa capacidade, abra o regedit, vá em HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesmemcached Server, encontre o item ImagePath e mude seu valor para: ?C:memcachedmemcached.exe? -d runservice -m 512. Pronto!

Bom, feito tudo isso espero ter unificado em português o que muitos sites em ingês dispersam.

O que venho a postar hoje pode até parecer heresia, mas é verdade, antes de ir ao conteúdo, vamos a uma perguntinha: Quem não depende de Windows como ambiente para desenvolver Sites/Portais/Sistemas que irão ser utilizados em 80%+ por usuários Windows? Sem maiores comentários.

Então, na busca por um ambiente Windows o mais parecido com meu atual ambiente de desenvolvimento Linux, tenho aqui uma série de coisas para compartilhar com vocês, a primeira delas é como configurar o eclipse + subclipse para utilizar svn+ssh sem vender sua alma ou fazer qualquer ritual.

É muito simples, de posse do eclipse ja com o plugin subclipse baixe o aplicativo Tortoise SVN, instale o mesmo da maneira que achar conveniente. Após isso vamos a simples configuração do mesmo. Abra para edição o seguinte arquivo:

c:Documents and Settings{seu usuario}Dados de AplicativosSubversionconfig

Nele você vai precisar tirar o comentário de algumas linhas e adicionar valores, vamos primeiro tirar os comentarios das seguintes linhas e modificar os valores, deixando essas linhas assim (após edição manter arquivo aberto):


[auth]

# Gravar a senha após autenticar, evita que você repita a senha 20 vezes em um checkout, update ou commit
store-passwords = yes
# Armazena sua identidade para próximas ações
store-auth-creds = yes


Feito isso, nosso svn+ssh não irá conectar de modo algum, é nesse momento que vemos a importancia de ter instalado na máquina o Tortoise SVN, além de você agora contar com um seu Windows Explorer como um navegador com suporte a SVN, você terá coisas úteis como tortoiseplink.exe, que será utilizado aqui para fazer o tunelamento da conexão, já que o nosso pobre Windows desconhece isso.

Precisamos então dizer ao Subversion que quem vai fazer o “tunnel” será o toroiseplink.exe, lá na sessão [tunnels] você terá uma opção para remover o comentário e utilizar o endereço completo do executável, no meu caso ficou assim:


[tunnels]
ssh = c:/Arquivos de programas/TortoiseSVN/bin/TortoisePlink.exe


É assim mesmo, com essa /, feito isso o recomendando no minimo é reiniciar o eclipse ou até mesmo o pc, caso essa solução não funcione, tente com variaveis de ambiente, cria uma chamada SVN_SSH e coloque o endereço do tortoiseplink.exe lá, e dessa vez utilizando \. Agora sim, pode dar um checkout e notar que ta tudo funcionando.

Meus estudos em geral giraram em torno de padrões, frameworks e ferramentas para agilizar o desenvolvimento e a criação de um ambiente “saudável” para desenvolvimento de grandes aplicações escaláveis e de fácil construção e manutenção. Ao final deste estudo com todos os méritos e baixa vantagem o vencedor foi o Zend Framework, anteriormente citado e futuramente será muito mais citado aqui neste blog.

Mas o Zend Framework por si só não atende a todas as necessidades de quem quer um ambiente otimizado e altamente escalável, o por que explicarei aqui para você leitor. Em um primeiro momento estarei citando algumas deficiências por nós encontradas no Zend Framework, e após citá-las falarei de como é simples contornar essas deficiências.

Pecados do Zend Framework:

1- Apesar de ser um legítimo MVC, o Zend Framework tem um sistema de templates que não pode ser comparado a por exemplo Smarty Template Engine. Para alguns isso pode parecer estranho, mas para quem abomina o fato do código PHP ser inserido dentro do HTML isso faz sentido.

2 – O framework tenta, mas não consegue convencer ninguem que faz Mapeamento Objeto-Relacional, não eficientemente, quem sabe em versões futuras do framework a Zend melhore isso, mas para quem precisa trabalhar com muitas tabelas, com muitas colunas e por consequencia um grande volume de dados, mas não precisa que todas as colunas sejam mapeadas por exemplo.

3 – Utilitario para geração de documentos PDF deixa a desejar. Por exemplo, precisávamos inserir uma tabela html dentro do PDF. Não deu, ele tem ótimos recursos para criar documentos, abrir e alterar, onde você trata o pdf como um objeto, altera o que quiser, muito bom, mas para relatórios fica complexo gerar tabelas na maneira que ele propõe.

Redenção do Zend Framework:

Você pode ter pensado “Ah, mas se é assim, por que vou usar o Zend Framework????”. É simples, o Zend Framework foi desenvolvido de tal maneira que seja totalmente desacoplados todos seu módulos, mas totalmente mesmo, juntando isso a sua alta coesão, resultado??? Você pode chegar e acoplar qualquer ferramenta conhecida e criar uma implementação dentro do padrão proposto pelo Zend (é claro, padrão é padrão) e ser literalmente ser FELIZ!

Nos próximos posts mostrarei aqui como fazer acoplamento de componentes ao Zend Framework, componentes como Smarty Template Engine, Doctrine ORM, TCPDF e muitos outros além de poder criar seus componentes reutilizáveis para qualquer aplicação.

Para minha sorte, como já tenho alguns projetos aprovados para inicio de desenvolvimento imediato, estou transferindo minha “carcaça” de aplicação toda para o modelo da Zend e claro, fazendo o acoplamento do Smarty Template Engine nele, com uma facilidade enorme. Para quem conhece, sabe do que eu estou falando, é claro que por aí encontramos muitos outros frameworks como CodeIgniter, e para quem não gosta de fato da Zend, como muitos xiitas que vemos por aí que não admitem o fato de termos uma Empresa por trás de uma linguagem, de uma IDE e até mesmo de um framework, esse texto é inútil.

Mas para aqueles buscam o respaldo de uma empresa séria e comprometida com resultados (assim como seus clientes é claro) vale a pena, pois assim temos um ambiente em constante evolução. Claro que não ganhei nada por esta propaganda toda, mas acho válido utilizar ferramentas que nos dão maior segurança, pois como no meu caso, desenvolvendo aplicações para grandes empresas de fora do Brasil, é impossível ficar na mão de uma ferramenta que vem “absolutamente sem garantia alguma”. Realmente, hoje em dia é essa a realidade, é a realidade de que devemos nos moldar as espectativas e necessidades de um mercado em constante mudança.

Para tanto não precisamos de muitas armas na mão, somente algumas extensões, bibliotecas e configurações finas. Pois bem, como alguns sabe, as funções mssql utilizam o ODBC e Freetds como base para suas operações. Então vamos à instalação de pacotes =):

# apt-get install php5-mssql freetds-dev tdsodbc unixodbc unixodbc-bin

Bem, segundo muitos materiais que encontrei por aí em inglês, garantem que o Freetds roda “fine” com o unixodbc, por isso decidi partir para esta última tentativa em busca da “felicidade” (por que ser feliz é usar mysql ou pgsql, não mssql). Então depois de instalar o freetds e o unixodbc, descobri que não se trataba apenas de instalar e deu, eu precisaria neste caso configurar algumas coisinhas, mas nada de mais. Primeiramente configurar o freetds, muito simples, só precisamos adicionar o driver padrão para conectarmos e mapear um servidor. Adicione o mapeamento ao final do arquivo /etc/freetds/freetds.conf conforme exemplo abaixo:

[MeuBanco]
host = meu.banco.dedados
port = 1433
tds version = 8.0
; A versão do tds tem um valor de acordo com o banco de dados a ser conectado, no meu caso precisei utilizar para o MsSql Server 2000 (Driver 8.0)
Abaixo vou listar todas as versões disponiveis para acesso via freetds:

* Sybase before System 10, Microsoft SQL Server 6.x:	tds version = 4.2
* Sybase System 10 and above:	tds version =	5.
* Microsoft SQL Server 7.0:	tds version =	7.0
* Microsoft SQL Server 2000:	tds version =	8.0
** Caso haja dúvida, teste com uma versão menor

Em alguns casos, parando por aqui já está tudo certo, vc tem acesso livre para conexão, mas agora estarei postando um extra, que é para garantir que seu apache/php irá autenticar diretamente no servidor mssql e você poderá acessar esse banco a partir de qualquer software linux, incluindo o OpenOffice Base. Então vamos lá para a configuração do UNIXODBC. Primeiramente você deve iniciar a edição do arquivo /etc/odbc.ini. Inserindo as seguintes configurações:

 [meubd]
Description     = FreeTDS
Driver          = FreeTDS
Servername      = meubd
Database        = aaa
UID             = bbb
PWD             = *******
Port            = 1433
E no arquivo /etc/odbcinst.ini adicione essas configurações:

 [FreeTDS]
Description     = Para conectar com MSSQL e Sysbase
Driver          = /usr/lib/odbc/libtdsodbc.so
Driver64        = /usr/lib
Setup           = /usr/lib/odbc/libtdsS.so
Setup64         = /usr/lib
UsageCount      = 1
CPTimeout       =
CPReuse         =

Vá até o arquivo /etc/php5/apache2/php.ini e faça a seguinte modificação:

#descomentem e caso for necessario modifiquem o charset da linha:
msssql.charset = "UTF-8"

Bom pessoal, acho que é somente isso, qualquer dúvida, problema ou sugestão em relação a esse passo-a-passo podem entrar em contato comigo que buscaremos a melhor solução.

Ps: Não esqueçam de reiniciar o daemon do apache!

Primeiro Caso: Meu servidor conta com PHP4 e PHP5, eu preciso do PHP5 como default, mas quando dou um php_info(); ele acusa o PHP4!

Primeira Solução (tosca pra caramba): Ao invés de utilizar a extensão .php, utilize .php5.

Segunda Solução (na medida): Crie um arquivo chamado .htaccess na raiz de onde vc deseja executar esses scripts, e insira o seguinte conteudo no arquivo:

AddType application/x-httpd-php5 .php
AddHandler application/x-httpd-php5 .php
Em alguns casos isso pode vir a não funcionar, então abaixo vou mostrar outras maneiras de forçar o apache a manipular os arquivos .php com o PHP5.
AddType x-mapp-php5 .php
AddHandler x-mapp-php5 .php
Esse aqui de cima confesso que demorei um pouco de tempo para descobrir, Hosts como 1and1.co.uk utilizam isso.

Bom pessoal, por hoje foi essa a micro-dica!