Ele traz uma API de banco de dados SQL Web, por enquanto ainda é uma especificação separada do HTML 5, mas já introduz um conjunto de APIs para manipular base de dados do lado do cliente utilizando SQL.

Estamos supondo que você já conheça e trabalhe com o SQL, mas caso não saiba o que é, recomendamos um mini curso de MySQL.

Por enquanto, Web SQL Database está suportado nas últimas versões do Chorme, Safari e Opera.

Esta postagem é baseada no artigo em inglês: Web SQL Database

Os métodos principais:

Há três seguintes métodos fundamentais definidos na especificação de que vamos mostrar nesta postagem:

1. openDataBase: Este método cria o objeto de banco de dados, depois utiliza um banco de dados existente ou criar um novo.
2. transaction: Este método controlar a transação e  nos retorna uma confirmação ou anulação com base no que foi executado.
3. executeSql: Este método é usado para executar um consulta SQL.

Abrindo Base de dados:

O openDataBase método cuida da abertura de um banco de dados se ele já existe, este método irá criá-lo se ele não existe.

Para criar e abrir um banco de dados, use o seguinte código:

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

Acima método tem quatro parâmetros:

1. Nome do banco
2. Número da versão
3. Descrição de texto
4. Tamanho da base de dados

Execução de consultas:

Para executar uma consulta, deve ser utilizado a função database.transaction (). Esta função precisa de um único argumento, mas pode ser passado o 2º e 3º parametro para verificar se foi completado com sucesso o comando, segue exemplo de duas consultas, uma simples e outra debugando:

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

// Simples
db.transaction (function (tx) {  
   tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log)");
});

// Debugando
db.transaction (function (tx) {  
   tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log)",
       function(tx){
           /*Sucesso*/
       },
       function(erro){
           /*Error*/
       });
});

As consultas acima irão criar uma tabela chamada LOGS na base de dados “Teste’.

Inserir dados:

Para inserir dados  na tabela, utilizamos a função transaction() também, só que, desta vez com o INSERT para popular a tabela, veja o exemplo:

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

db.transaction (function (tx) {
   tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log)");

   // Os 3 null represetam
   // 1º - Um array contendo dados
   // 2º - Função para sucesso
   // 3º - Função para Erro
   // Vamos explicá-los mais abaixo
   tx.executeSql ("INSERT INTO LOGS (log) VALUES ('Resultado do Log de Teste 01') ", null, null, null);
   tx.executeSql ("INSERT INTO LOGS (log) VALUES ('Resultado do Log de Teste 02') ", null, null, null);
});

Também podemos passar valores dinâmicos, utilizamos a seguinte sintaxe:

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

db.transaction (function (tx) {

  var novo_log = 'Resultado do Log de Teste 01';

   // Os 3 null estão sendo mostrados aqui
   // 1º - Um array contendo dados, estamos passando apenas um valor com o novo_log
   // 2º - Função para sucesso
   // 3º - Função para Erro
   // Vamos explicá-los mais abaixo
  tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log)");
  tx.executeSql ("INSERT INTO REGISTROS (log) VALUES (?)",[novo_log],null,null);						
});

Aqui novo_log é uma variável e executeSql mapeia cada item no argumento de matriz para o “?”, isto é, poderíamos ter vários “?” e no final teríamos [var_1,var_2,var_3], sendo que, ele utilizará a ordem exata das variáveis para popular a query.

Lendo os dados:

Para ler os registros já existentes usamos um callback para capturar os resultados da seguinte forma:

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

db.transaction (function (tx) {
    tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log TEXT)",null,null);
    tx.executeSql ("INSERT INTO LOGS (log) VALUES (?)",['Resultado do Log de Teste 01'],null,null);
    tx.executeSql ("INSERT INTO LOGS (log) VALUES (?)",['Resultado do Log de Teste 02'],null,null);
});

db.transaction (function (tx) {
   tx.executeSql ('SELECT * FROM LOGS', [], function (tx, results) {
   var len = results.rows.length, i;
   msg = "<p> Registros encontrados:" + len + "</ p>";
   for (i = 0; i <len; i ++) {
      console.log(results.rows.item(i) .log);
   }
 }, null);
});

Exemplo final:

Então, finalmente, vamos  criar um exemplo em HTML 5,  este exemplo está funcional e testado no Chrome versão Versão 39.0.2171.71 m.

var db = openDatabase ('Teste', '1.0', 'Teste Web SQL Database', 2 * 1024 * 1024);

db.transaction (function (tx) {
    tx.executeSql ("CREATE TABLE IF NOT EXISTS LOGS (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, log TEXT)",null,null);
    tx.executeSql ("INSERT INTO LOGS (log) VALUES (?)",['Resultado do Log de Teste 01'],null,null);
    tx.executeSql ("INSERT INTO LOGS (log) VALUES (?)",['Resultado do Log de Teste 02'],null,null);
   console.log('Log mensagem criada e linha inserida');
});

db.transaction(function(tx){
    tx.executeSql(       
        "SELECT * FROM LOGS",
        [],
        function(tx, result){
            console.log('Deu certo!');
            var len = result.rows.length, i;
            for(i=0;i<len;i++){
                console.log( result.rows.item(i) );
            }
        },
        function(tx, error){
            console.log('Deu errado!');
            console.log(error);
        }
    );
});

Isso produziria o seguinte resultado:

Log mensagem criada e linha inserida
Deu certo!
Object {id: 1, log: "Resultado do Log de Teste 01"}
Object {id: 2, log: "Resultado do Log de Teste 02"}

Conclusão:

É bem simples utilizar e depende apenas de um pouco de treino, nos testes detectamos que a sua persistência é como uma sessão, ao fechar o browser perde-se o objeto, mas ao trocar de página dentro do mesmo domínio o mesmo permanece.

Já pensou em utilizar esta nova funcionalidade com o evento onBeforeUnload para rastrear todo o caminho que um usuário caminhou dentro do seu site? A utilização ficará por conta da imaginação de vocês.

Um exemplo que encontramos no GitHub e que vale a pena ver:
Link original do código aqui.

https://gist.github.com/andyj/1599544

Link de uma aplicação feita com Web Sql.
HTML5 webSQL app synching with a php MySQL server

Se gostaram, compartilhem e façam comentários, sugestões, correções e correções sempre são bem vindas. A Turbosite tem o comprometimento em divulgar conhecimento!

Quer servidores Seguros, Estáveis, com uptime de 99,9%, no Brasil e de baixo Custo? A Turbosite é sua resposta.

Hospedagem de Sites, Data Center e Registro de Domínio Grátis só aqui!

Vamos supor que temos 2 tabelas relacionadas, clientes e telefones. O cliente tem a seguinte estrutura:

CREATE TABLE `clients` (
  `idClients` int(11) NOT NULL AUTO_INCREMENT,
  `name` char(150) DEFAULT NULL,
  PRIMARY KEY (`idClients`)
)
insert  into `clients`(`name`) values ('Turbosite');

Note que no final inserimos um usuário para nosso teste.

A tabela de telefones ficaria desta forma:

CREATE TABLE `phones` (
  `idPhones` int(11) NOT NULL AUTO_INCREMENT,
  `number` char(20) NOT NULL,
  `idClients` int(11) NOT NULL,
  PRIMARY KEY (`idPhones`,`idClients`),
  KEY `idClients` (`idClients`),
  CONSTRAINT `phones_ibfk_1` FOREIGN KEY (`idClients`) REFERENCES `clients` (`idClients`)
)
insert  into `phones`(`number`,`idClients`) values ('(31) 4003-2322',1);
insert  into `phones`(`number`,`idClients`) values ('(31) 3261-2168',1);

Sem utilizar o NATURAL Join, a consulta para pegar os telefones de um cliente seria da seguinte forma:

SELECT C.`name`,P.`number` FROM clients C
INNER JOIN phones P
ON C.`idClients` = P.`idClients`
WHERE C.`idClients` = 1

Resultado seria:

Agora com o Natural JOIN, a consulta seria:

SELECT * FROM clients
NATURAL JOIN phones
WHERE idClients = 1

O resultado da pesquisa:

O Natural JOIN é inteligente o suficiente para não acusar erro por ambiguidade de coluna, como uma faz referência a outra, ele não lista em duplicidade as colunas de referência.
A consulta fica mais limpa, mais fácil de entender e de dar manutenção, caso esta tabela fizesse referência a uma 3ª tabela, era só adicionar uma linha ficando desta forma:

SELECT * FROM clients
NATURAL JOIN phones
NATURAL JOIN tabela3
WHERE idClients = 1

Vamos deixar aqui um link com uma apresentação de JOINS do MYSQL. É interessante ver e aprender para tomar a melhor decisão no desenvolvimento de seus projetos.

http://w3resource.com/gallery/mysql-joins-slides-presentation

Deprecated: The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead

Querendo ou não, o desligamento da antiga ferramenta MySQL é inevitável. Sem dúvida, o trabalho para conseguir migrar todas as funções de conexão com o MySQL para uma outra ferramenta, em provavelmente grande parte de seus projetos, vai ser custosa e demorada. Porém, é muito provável que seus esforços serão recompensados. Em seu site, a PHP nos indica duas ferramentas de conexão com o MySQL: a MySQLi (Improved) e o PDO.

A extensão original MySQL está agora obsoleta e irá gerar erros E_DEPRECATED quando conectar à um banco de dados. Em seu lugar, use a extensão MySQLi ou PDO MySQL.

A equipe da Turbosite retirou do blog Code um artigo que explica em detalhes o funcionamento e as diferenças de cada ferramenta. Detalhando código para conexão, querys, detalhes de segurança e desempenho. Abaixo você confere as diferenças entre essas duas ferramentas.

Comparativo

Conexão

Criar uma conexão com uma base de dados é fácil em ambas as ferramentas:

// PDO
$pdo = new PDO("mysql:host=servidor;dbname=banco_de_dados", 'usuario', 'senha');
  
// MySQLi, forma procedural
$mysqli = mysqli_connect('servidor', 'usuario', 'senha', 'banco_de_dados');
  
// MySQLi, forma via orientação a objetos
$mysqli = new mysqli('servidor', 'usuario', 'senha', 'banco_de_dados');

Suporte de API

Tanto PDO quanto MySQli oferecem um API orientada a objetos, mas o MySQLi também oferece uma API procedural – facilitando o entendimento por parte dos novatos. Se você já é familiarizado com o driver nativo do MySQL para PHP, migrar para a interface procedural do MySQLi será extremamente simples. Por outro lado, uma vez que você compreender a PDO, você poderá usá-la com qualquer banco de dados que desejar!

Suporte a Bancos de Dados

A principal vantagem do PDO sobre o MySQLi é seu suporte aos drivers de diversos bancos de dados. No momento em que traduzimos esse artigo, o PDO dá suporte a 12 tipos diferentes de drivers, enquanto o MySQLi só dá suporte ao MySQL.

Caso queira saber quais os drivers que o PDO dá suporte no momento, use o código a seguir:

var_dump(PDO::getAvailableDrivers());

O que isso significa? Bem, em situações que você precisar usar outro banco de dados, a PDO torna esse processo transparente. Então, a única coisa que você precisará fazer é mudar os parâmetros de conexão e algumas consultas, isso se elas usarem algum método que não seja suportado por outra base de dados. Já com o MySQLi, você precisará reescrever todo o código que lida com banco de dados,  inclusive as consultas.

Parâmetros Nomeados

Essa é outra característica importante que o PDO tem. Vincular parâmetros com PDO é muito mais fácil usando a vinculação nomeada:

$params = [':usuario' => 'teste', ':email' => $email => ':ultimo_login' => time() - 3600];
  
$pdo->prepare('SELECT * FROM users WHERE username = :usuario AND email = :email AND las_login = :ultimo_login');
  
$pdo->execute($params);

Ao contrário da maneira do MySQLi:

$query = $mysqli->prepare('SELECT * FROM users WHERE username = ? AND email = ? AND lasT_login = ?');
  
$query->bind_param('teste', $mail, time() - 3600);
$query->execute();

A vinculação dos parâmetros na forma de interrogação pode parecer menor, mas, nem de longe, é tão flexível quanto aos parâmetros nomeados, devido ao fato do desenvolvedor ser obrigado a saber a ordem dos parâmetros. Ela parece um hack feito para permitir vinculação de parâmetros em algumas circunstâncias.

Infelizmente, MySQLi não dá suporte a parâmetros nomeados.

Mapeamento de Objetos

Tanto PDO quanto MySQLi podem mapear resultados em objetos. Isso vem bem a calhar se você não quer usar uma camada de abstração de banco de dados customizada, mas ainda quer um comportamento semelhante ao de um ORM. Vamos imaginar que nós temos uma classe User com algumas propriedades nomeadas de forma idêntica aos campos da tabela do Banco de Dados:

class User {
public $id;
public $first_name;
public $last_name;
  
public function info()
{
return "#" . $this->id . ": " . $this->first_name . " " . $this->last_name;
}
}

Sem o mapeamento de objetos, nós precisaríamos preencher cada um dos campos (fosse manualmente ou através de um método construtor), anes de podermos usar o método info() corretamente.

Isso permite que nós predefinamos as propriedades antes mesmo do objeto ser construído! Por exemplo

$query = "SELECT id, first_name, last_name FROM users";
  
// PDO
$result = $pdo->query($query);
$result->setFetchMode(PDO::FETCH_CLASS, 'User');
  
while ($user = $result->fetch()) {
echo $user->info() . "\n";
}
  
// MySQLi, forma procedural
if ($result = mysqli_query($mysqli, $query)) {
while ($user = mysqli_fetch_object($result, 'User')) {
echo $user->info() . "\n";
}
}
  
// MySQLi, forma orientada a objetos
if ($result = $mysqli->query($query)) {
while ($user = $result->fetch_object('User')) {
echo $user->info() . "\n";
}
}

Segurança

Ambas as bibliotecas proveem segurança contra injeção de SQL, desde que o desenvolvedor as use da maneira que elas foram planejadas para usar. Digamos que um hacker esteja tentando injetar algum código malicioso através de um parâmetro ‘username’ de uma requisição HTTP GET:

$_GET['username'] = "'; DELETE FROM users; /*"

Se nós falharmos em limpá-lo, ele será incluído na consulta exatamente como está  e deletará todas linhas da tabela users (tanto PDO quanto MySQLi suporta múltiplas consultas).

// PDO, limpeza manual
$username = PDO::quote($_GET['username']);
  
$pdo->query("SELECT * FROM users WHERE username = $username");
  
// MySQLi, limpeza manual
$username = mysqli_real_escape_string($_GET['username']);
  
$mysqli->query("SELECT * FROM users WHERE username = '$username'");

Como podem ver, PDO::quote() não só valida, mas fixa as aspas. Por outro lado, mysqli_real_escape_string() só limpará, forçando você a fixar as aspas manualmente.

// PDO com sentenças preparadas
$pdo->prepare('SELECT * FROM users WHERE username = :username');
$pdo->execute([':username' => $_GET['username']]);
  
// MySQLi, sentenças preparadas
$query = $mysqli->prepare('SELECT * FROM users WHERE username = ?');
$query->bind_param('s', $_GET['username']);
$query->execute();

Recomendamos que você sempre use sentenças preparadas com consultas vinculadas ao invés da PDO::quote() e da mysqli_real_scape_string().

Performance

Tanto PDO quanto MySQLi são bem rápidas, porém, MySQLi se sai mais rápida nos comparativos; ~2,5% para sentenças não preparadas e ~6,5% para as sentenças preparadas. Porém, a extensão nativa do MySQL é ainda mais rápida que ambas. Mas, como afirmei no começo, ela não é mais uma opção.

Conclusão

PDO possuí suporte a 12 drivers de bases de dados diferentes e parâmetros nomeados. MySQLi ganha em desempenho, comparado com o PDO  e possui uma sintaxe mais simples, facilitando a migração a partir do antigo MySQL. Com relação à segurança, ambas são seguras, desde que o desenvolvedor saiba usá-las da forma correta.

Em especial, deixaremos a conclusão desse artigo para o leitor. Caso você esteja procurando desempenho em suas querys e não quer esquentar a cabeça para aprender uma nova ferramenta de conexão com o banco de dados, talvez o MySQLi seja sua melhor escolha. Caso você esteja procurando uma ferramenta mais completa e robusta, o PDO MySQL seria a melhor escolha.

Deixe-nos sua resposta, faça um comentário abaixo falando qual ferramenta você escolheu o por quê.

Dos três modos de otimização (configuração de hardware do servidor, configuração de rede do servidor e otimização de código), apresentamos aqui métodos para otimização por código MySQL.

MYSQLREPORT

Como primeiro passo, você pode usar o comando MYSQLREPORT para gerar relatórios sobre bancos de dados que estão atingindo o limite de sua capacidade de uso  e estabelecer um patamar para operações e usos adicionais. Talvez também você se veja obrigado a modificar arquivo de configuração (my.cnf) para registrar o log de consultas lentas. Identifique as consultas que estão processando muito devagar e as possíveis causas.

Para acessar a documentação completa do MYSQLREPORT, recomendamos esse link: man.he.net/man1/mysqlreport.

EXPLAIN

Aplique o comando EXPLAIN antes do script SELECT para o MySQL retornar um registro contendo a análise do script para aquela tabela consultada. Esse método retorna algumas informações, como ID, SELECT_TYPE, TABLE, TYPE, KEY_LEN, REF, sendo que as informações que você vai querer para avaliar o desempenho do código são:

• POSSIBLE_KEYS: mostra os índices disponíveis para serem utilizados naquela consulta;
• KEY: mostra o índice escolhido pelo MySQL para realizar a consulta;
• ROW: número estimado de linhas percorridas para encontrar o resultado do SELECT;
• EXTRA: sugestões de otimização em índices da consultas, como usar DISTINCT, NOT EXIST, USING INDEX, entre outras.

EXPLAIN SELECT * FROM funcionarios;

ANALYZE

Use o comando ANALYZE para gerar uma distribuição de chaves, para a tabela a ser utilizada pelo otimizador de consultas do MySQL, para decidir quais índices serão melhores se utilizados em uma consulta.

ANALYZE TABLE funcionarios;

OPTIMIZE 

Se há grandes quantidades de inserções/exclusões em uma tabela, principalmente se a tabela conter muitos campos do tipo varchar, text e blob, o disco será comprometido à várias fragmentações. O comando OPTIMIZE deve ser usado com freqüência para esse tipo de situação. O comando ira otimizar a movimentação da cabeça de leitura e gravação do disco durante a recuperação de dados, implementando a desfragmentação do disco causada por campos de comprimento variável.

OPTIMIZE TABLE funcionarios;

LOAD DATA INFILE

Para a importação de dados para uma tabela, o comando LOAD DATA INFILE, no lugar do comando SELECT, irá apresentar um desempenho até 20 vezes melhor.

LOAD DATA INFILE 'filedata.dat' INTO TABLE funcioanrios (col1,col2,...,colM) 
     FIELDS TERMINATED BY '|'");

TRUNCATE

O comando DELETE deleta linha por linha, enquanto TRUNCATE deleta todas as linhas de uma só vez. Portanto, se você não estiver interessado no número de linhas suprimidas de uma tabela, como resultado do comando DELETE, utilize o comando TRUNCATE com a seguinte sintaxe:

TRUNCATE TABLE funcionarios;

Prioridade dos comandos

Se há mais consultas do que inserções de dados, você pode ter uma prioridade mais baixa do comando INSERT utilizando

INSERT LOW_PRIORITY

ou

SELECT HIGH_PRIORITY

Se o cliente não está interessado nos resultados do comando INSERT, então esta operação já pode imediatamente utilizar menos os recursos do sistema, utilizando-se o seguinte comando:

INSERT DELAYED

Isso torna o sistema mais rápido porque acumula as inserções em lotes.

Permissões no MySQL

Além de incrementar na segurança da conexão, criar usuários com permissões específicas reduzem o overhead das verificações das permissões em todos os comandos realizados no MySQL, melhorando assim no desempenho do sistema. Como exemplo, um leitor do blog apenas tem interesse na leitura de postagem, leitura e inserção de comentários. Criar um usuário de nome “leitor”, com acesso apenas a leitura da tabelas ‘postagens’, e acesso a leitura e escrita à tabela ‘comentarios’, será de fato uma boa prática. A segurança será incrementada, já que aquele usuário não terá permissão de acessar, modificar ou deletar outros registros que não são de seu respeito, como também o desempenho, já que o overhead do usuário constará suas propriedades de acessos de antemão.

GRANT Oper1,...,OperN ON db_name.tb_name TO user_name@computer_name IDENTIFIED BY password;

BENCHMARK

Por fim, para saber quanto tempo uma determinada função ou expressão MySQL está demorando, use a função MySQL embutida:

SELECT BENCHMARK ( 10000, ( SELECT col1 FROM funcionarios LIMIT 1 ) );

Lembrando que, para passar consultas na função BENCHMARK, obrigatoriamente a query deve retornar 1 linha com 1 coluna.

 Outras dicas corriqueiras

• Utilize ORDER BY sempre na primeira tabelas, de preferência em índices, quando estiver realizando uma consulta em várias tabelas interligadas;
• Utilize LIMIT, o MySQL irá primeiro avaliar o comando LIMIT para depois executar funções como ORDER BY e GROUP BY;
• Realize UPDATE e INSERT em um lote inteiro de registros, de uma só vez, além de realizar uma ação por cada registro;
• Remova parênteses desnecessários na cláusula WHERE.

Referências: Como otimizar consultas MySQL, Using EXPLAIN to Write Better MySQL Queries, Como otimizar consultas no MySQL-Análise das queries.