Bash: executando o último comando

se você quer executar novamente o último comando completo, use:

prompt> !!

isso é útil, por exemplo, se você esqueceu de colocar o sudo na frente do último comando. assim é necessário apenas fazer:

prompt> apachectl stop
This operation requires root.

prompt> sudo !!
sudo apachectl stop

muito simples.

Bash: último argumento do comando anterior

se você executa, por exemplo:

prompt> ls -la /usr/bin/vi

e agora vc quer executar o /usr/bin/vi. é só executar:

prompt> !$

isso esquivale a fazer:

prompt> /usr/bin/vi

pois o !$ insere na linha de comando o último argumento usado no comando anterior.


outro exemplo:

prompt> ls -la /etc/my.cnf

agora vc quer ver o conteúdo do arquivo /etc/my.cnf?

prompt> cat !$

simples e fácil.

PHP - Números preenchidos com zeros a esquerda

e vc precisa de números preenchidos com zeros a esquerda, o PHP proporciona um jeito fácil de fazer isso:

 printf("%05d", -654);

Traduzindo a formatação 05d:


0 – preencher com zeros a esquerda, se o número de caracteres é inferior ao requerido;
5 – é o mínimo de caracteres requerido;
d – trata o argumento inteiro como um decimal respeitando seu sinal.


A função printf escreve a string formatada direto na saída padrão. Se precisar jogar essa string em uma variável, use sprintf da mesma forma.

Magento dando erro no login

Magento 1.3.2.4 está apresentando um erro bem estranho: não permite login através de qualquer browser, apenas no Safari e Opera funciona. No Firefox, no Chrome e no IE aparece um erro como se os cookies estivessem desabilitados, mas verificando estava tudo ok.

Pesquisei um pouco e encontrei uma solução no próprio fórum do Magento. Ele está com um bug em seu javascript que aparece quando o sistema está sendo executado no localhost.

Pra funcionar use http://127.0.0.1 em vez de http://localhost e tudo funciona “normalmente”. Isso pode ser feito na instalação, quando é escolhido o host ou, se já estiver instalado, no admin (com um dos browsers que funciona) em System ›› Configuration ›› Web, trocando tudo que for localhost por 127.0.0.1.

Coloquei o sistema em um subdomínio pra testar e não deu esse problema. Parece que é só com o localhost mesmo.

MySQL: insert x insert ignore x replace

Alguns detalhes que muitas vezes são ignorados podem facilitar muito a vida no MySQL.


INSERT

Talvez o INSERT seja o segundo comando SQL mais conhecido, perdendo apenas para o SELECT. Ele insere novos registros em uma tabela existente. Caso o INSERT esteja tentando inserir um registro que tenha a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, ocorre um erro chamado erro de chave duplicada (duplicate-key error) e a execução é abortada.

Se esse erro ocorrer no meio de um script SQL, a execução do script é abortada.


REPLACE

Funciona exatamente como o INSERT, porém se o registro que está sendo inserido tem a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, esse registro já existente é apagado antes do novo ser inserido. E não ocorre erro.

INSERT IGNORE

A cláusula IGNORE altera um pouco o comportamento do INSERT:

Se o registro que está sendo inserido tem a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, o INSERT IGNORE é ignorado e não ocorre erro.


Tentativas de inserir registros com valores inválidos não causam erros. Os valores serão ajustados para valores mais aceitáveis e inseridos. Warnings são produzidos, mas a execução não é abortada.

Resumindo

DELETE FROM `table`;

INSERT INTO `table` (`id`, `name`) VALUES (1, "Adriana");
INSERT INTO `table` (`id`, `name`) VALUES (1, "Pedro");
INSERT INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro INSERT será executado, o segundo dará erro e a execução será abortada (pois já foi inserido um registro com id = 1), o terceiro nem será executado.

Resultado:

+----+---------+
| id | name    |
+----+---------+
|  1 | Adriana |
+----+---------+

DELETE FROM `table`;
REPLACE INTO `table` (`id`, `name`) VALUES (1, "Adriana");
REPLACE INTO `table` (`id`, `name`) VALUES (1, "Pedro");
REPLACE INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro REPLACE será executado inserindo normalmente o registro como o INSERT faria. O segundo apagará o registro com id = 1 e adicionará outro registro com id = 1 sem erros. O terceiro REPLACE também será executado normalmente.

Resultado:

+----+--------+
| id | name   |
+----+--------+
|  1 | Pedro  |
|  2 | Rafael |
+----+--------+

DELETE FROM `table`;
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (1, "Adriana");
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (1, "Pedro");
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro INSERT IGNORE vai inserir o registro exatamente como o INSERT sozinho faria. O segundo vai tentar inserir outro registro, mas como a chave está duplicada, será ignorado sem erros. O terceiro INSERT IGNORE também será executado normalmente.

Resultado:

+----+---------+
| id | name    |
+----+---------+
|  1 | Adriana |
|  2 | Rafael  |
+----+---------+

git svn switch relocate

quando o repositório svn o qual foi feito o clone com o git-svn é movido, é preciso fazer alguns ajustes no git-svn pra poder continuar usando sem problemas. algo como um “svn switch—relocate” pra quem já está acostumado com o svn.

quem está acostumado com o git e conhece o arquivo .git/config pensa logo em alterar o valor da “url” em “svn-remote”. o problema é que somente isso não funciona. alguns passos devem ser seguidos:

- alterar o arquivo .git/config, com a nova svn-remote url do svn;

- executar um “git svn fetch” pra pegar a última revisão do svn. um detalhe importante: tem que vir alguma alteração do svn pra poder funcionar;

- alterar a svn-remote url para a url antiga;

- executar “git svn rebase -l” pra fazer um rebase local com as alterações que o fetch pegou. por isso que o fetch tem que trazer alguma alteração, senão o rebase não faz nada;

- alterar novamente a svn-remote url pra nova url do svn;

- executar “git svn rebase”. isso deve funcionar sem erros agora. e a partir daí já se consegue dar “git svn dcommit” sem problemas para o novo repositório svn.

referência: http://git.or.cz/gitwiki/GitSvnSwitch

Configuração de upload em PHP

O programador não pode esquecer de algumas coisas quando vai trabalhar com upload de arquivos em PHP. Principalmente as diretivas do php.ini.

As que ninguém esquece:

upload_max_filesize



define qual o tamanho máximo permitido por arquivo. o valor padrão é 2 megas. se o arquivo exceder esse limite, $_FILES["file"]["error"] chega com valor 1.


file_uploads


define se é permitido o upload de arquivos. o valor padrão é On.


upload_tmp_dir


define o diretório temporário usado para guardar os arquivos de upload. o usuário que está executando o web script (em geral, o mesmo usuário do Web Server) deve ter permissão de escrita nesse diretório. se não for especificado, será usado o diretório temporário padrão do sistema.

O que quase ninguém lembra:

post_max_size


muito importante! define o tamanho máximo dos dados enviados via POST. isso afeta diretamente o upload de arquivos. esse valor deve sempre ser maior que upload_max_filesize! o valor padrão é 8 megas.


se o tamanho de dados exceder o valor de post_max_size, $_POST e $_FILES chegarão vazios. e por isso
eu
muita gente
fica horas pra descobrir porque consegue fazer upload de arquivos pequenos mas não consegue com arquivos grandes. não dá erro, o arquivo simplesmente não chega. diferente do que acontece quando o arquivo excede apenas o upload_max_filesize.


memory_limit


define a quantidade máxima de memória que o script pode alocar. isso também afeta upload de arquivos. o manual do PHP fala que memory_limit deve ser maior que post_max_size, mas eu mesmo já consegui fazer upload de arquivos maiores que o valor configurado nessa diretiva. vai entender! valor padrão: 128 megas.


observação importante: todas essas diretivas que definem tamanho recebem o valor em bytes. porém, como o PHP tem a péssima mania de querer fazer tudo ao mesmo tempo, pode ser usado uma notação mais amigável: K (pra Kilobyte), M (pra Megabyte) and G (pra Gigabyte). por exemplo: 1K ao invés de 1024. isso só vale dentro do php.ini.


exemplo prático do uso das diretivas acima. no php.ini:

; Maximum allowed size for uploaded files.
upload_max_filesize = 100M

; Whether to allow HTTP file uploads.
file_uploads = On

; Temporary directory for HTTP uploaded files (will use system default if not specified).
; upload_tmp_dir =

; Maximum size of POST data that PHP will accept.
post_max_size = 128M

; Maximum amount of memory a script may consume (8MB)
memory_limit = 256M