{"id":2407,"date":"2016-01-28T09:12:46","date_gmt":"2016-01-28T13:12:46","guid":{"rendered":"http:\/\/linguagemprisma.br4.biz\/blog\/?page_id=2407"},"modified":"2016-02-20T17:15:11","modified_gmt":"2016-02-20T21:15:11","slug":"tutorial-banco-de-dados-sqlite3-prisma","status":"publish","type":"page","link":"https:\/\/linguagemprisma.br4.biz\/blog\/tutorial-banco-de-dados-sqlite3-prisma\/","title":{"rendered":"Tutorial banco de dados sqlite3 prisma"},"content":{"rendered":"

TUTORIAL SQLITE3 PRISMA <\/b><\/span><\/span><\/span><\/p>\n

Por Adalberto<\/b><\/span><\/span><\/span><\/p>\n

\"\"<\/p>\n

 <\/p>\n

Link para a lista de fun\u00e7\u00f5es sqlite3 Prisma.<\/a><\/p>\n

 <\/p>\n

Nota: Problemas no Win resolvidos, releia a parte 4,\u00a0<\/strong>exemplo\u00a0j\u00e1 modificado.<\/p>\n

Eu, pessoalmente recomendo muito o Linux, especialmente o Ubuntu. Pode acreditar, vai evitar tremendas dores de cabe\u00e7a, inclusive se for correr um servidor nele.<\/p>\n

Requisitos m\u00ednimos:<\/b><\/span><\/span><\/span><\/p>\n

    \n
  1. instala\u00e7\u00e3o completa prisma-1.0 mais recente;<\/span><\/span><\/span><\/li>\n
  2. saber criar um arquivo fonte com prismacod ou outro editor e execut\u00e1-lo com o interpretador prisma.<\/span><\/span><\/span><\/li>\n
  3. Caso n\u00e3o tenha o b\u00e1sico de entendimento, sugiro que visite o site www.linguagemprisma.br4.biz<\/a>, baixe prisma ‘tudo em um’, siga os primeiros passos e leia o manual b\u00e1sico da linguagem prisma;<\/span><\/span><\/span><\/span><\/li>\n<\/ol>\n

    Com este tutorial voc\u00ea aprender\u00e1 a:<\/b><\/span><\/span><\/span><\/p>\n

    \u00a0 \u00a0 \u00a0 \u00a00. <\/strong><\/span><\/i>Defini\u00e7\u00e3o resumida de<\/i> banco de dados;<\/i><\/strong><\/span><\/span><\/span><\/span><\/p>\n

      \n
    1. mostrar a vers\u00e3o do sqlite3;<\/i><\/span><\/span><\/span><\/li>\n
    2. abrir\/criar banco de dados;<\/i><\/span><\/span><\/span><\/li>\n
    3. criar tabelas e preencher com dados;<\/i><\/span><\/span><\/span><\/li>\n
    4. ler e mostrar os dados;<\/i><\/span><\/span><\/span><\/li>\n
    5. pegar o n\u00famero atual de registros id de uma tabela;<\/i><\/span><\/span><\/span><\/li>\n
    6. pegar o nome de todas as tabelas existentes em um bd;<\/i><\/span><\/span><\/span><\/li>\n
    7. deletar e atualizar os dados de uma tabela;<\/i><\/span><\/span><\/span><\/li>\n<\/ol>\n

      0 \u2013 Defini\u00e7\u00e3o resumida de banco de dados;<\/b><\/span><\/span><\/span><\/p>\n

      Resumidamente, \u00e9 um arquivo criado por um programa para armazenar dados de modo organizado, sendo poss\u00edvel, posteriormente, consultar ou modificar esses dados pelo programa;<\/span><\/span><\/span><\/p>\n

      1 \u2013 Mostrar a vers\u00e3o do sqlite3;<\/b><\/span><\/span><\/span><\/p>\n

      Crie um arquivo chamado sql_versao.prisma e copie o conte\u00fado abaixo:<\/span><\/span><\/span><\/p>\n

      \u00a0<\/span><\/span><\/span><\/span><\/p>\n

      local sql = inclua'sqlite3';\r\n\r\nimprima( sql.libversao() );\r\n\r\n\/\/ sa\u00edda--> 3.9.2<\/pre>\n
      No c\u00f3digo fonte acima temos:<\/p>\n
      local sql = inclua’sqlite3′;<\/span><\/span><\/span><\/span><\/p>\n
      Esta linha serve para importar as fun\u00e7\u00f5es da biblioteca sqlite3.pris para a vari\u00e1vel ‘sql’;<\/span><\/span><\/span><\/p>\n
      imprima( sql.libversao() ); <\/span><\/span><\/span><\/p>\n
      Acima temos duas fun\u00e7\u00f5es: <\/span><\/span><\/span><\/p>\n
      *’imprima()* \u2013 que serve para mostrar um texto ou n\u00famero na tela de comandos do Linux ou Windows.<\/span><\/span><\/span><\/p>\n
      *sql.libversao()* \u2013 esta fun\u00e7\u00e3o retorna um texto (string) descrevendo a vers\u00e3o do sqlite3.<\/span><\/span><\/span><\/p>\n
      2 \u2013 abrir\/criar banco de dados; <\/b><\/span><\/span><\/span><\/p>\n
      salve como: cria_bd.prisma<\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/span><\/span><\/span><\/p>\n
      local sql = inclua 'sqlite3';\r\n\r\nret , base = sql.abra( \"teste.bd\" );\r\n\r\nse ret == sql.SQLITE_OK entao\r\n\r\nimprima 'base criada com sucesso!\\n';\r\n\r\nsenao\r\n\r\nimprima( \" ERRO: \" , sql.mensagem_erro(base) );\r\n\r\nfim\r\n\r\nsql.feche(base);\r\n\r\nleia();<\/pre>\n
      Detalhes:<\/p>\n
      local sql = inclua ‘sqlite3’;<\/b><\/span><\/span><\/span><\/p>\n
      No trecho acima inclu\u00edmos as fun\u00e7\u00f5es da biblioteca sqlite3 na tabela sql; <\/span><\/span><\/span><\/p>\n
      ret, base = sql.abra(‘teste.bd’);<\/b><\/span><\/span><\/span><\/p>\n
      Nesta linha abrimos o arquivo ‘teste.bd’ de banco de dados ( \u00fanico par\u00e2metro \u00e9 uma string descrevendo o nome do arquivo \/ caso n\u00e3o exista o arquivo, \u00e9 criado um, caso exista, \u00e9 aberto para leitura ou grava\u00e7\u00e3o) e s\u00e3o retornados dois valores: ret e base.<\/span><\/span><\/span><\/p>\n
      Entendendo os dois retornos:<\/b><\/span><\/span><\/span><\/p>\n
      *ret \u2013 <\/b>\u00e9 um n\u00famero que indica \u00eaxito (zero) ou erro (qualquer outro n\u00famero);<\/span><\/span><\/span><\/p>\n
      *base<\/b> \u2013 \u00e9 uma vari\u00e1vel do banco de dados aberto. (os nomes dos retornos ficam a crit\u00e9rio do programador, aqui eu escolhi ret e base mas poderiam ser outros.)<\/i><\/span><\/span><\/span><\/span><\/p>\n
      ( Obs. a vari\u00e1vel tabela sql <\/b>recebeu o retorno da fun\u00e7\u00e3o inclua’sqlite3′; \u00e9 por isso que podemos usar os m\u00e9todos ap\u00f3s escrever sql.<\/b> )<\/i><\/p>\n
      se ret == sql.SQLITE_OK entao\r\n\r\nimprima 'base criada com sucesso!\\n';\r\n\r\nsenao\r\n\r\nimprima( \" ERRO: \" , sql.mensagem_erro(base) );\r\n\r\nfim<\/pre>\n
       <\/p>\n
      Aqui pode ser lido como: se o retorno ret for igual a sql.SQLITE_OK ent\u00e3o coloque na tela a frase de sucesso! Caso contr\u00e1rio (se ret n\u00e3o for igual a sql.SQLITE_OK) imprima a mensagem de erro.<\/span><\/span><\/span><\/p>\n
      *Nota \u2013 SQLITE_OK \u00e9 uma vari\u00e1vel reservada da biblioteca sqlite3 que tem como valor o n\u00famero zero.<\/i><\/span><\/span><\/span><\/p>\n
      A fun\u00e7\u00e3o  sql.mensagem_erro(base) <\/b>retorna uma string descrevendo o \u00fatimo erro contido em ‘base’ que \u00e9 a vari\u00e1vel do banco de dados aberto, lembra. \u00danico par\u00e2metro \u00e9 a vari\u00e1vel do banco de dados aberto.<\/span><\/span><\/span><\/p>\n
      sql.feche(base);<\/b><\/span><\/span><\/span><\/p>\n
      E por fim, n\u00e3o se esque\u00e7a de fechar o banco de dados aberto com a fun\u00e7\u00e3o acima.<\/span><\/span><\/span><\/p>\n
      3 \u2013 criar tabelas e preencher com dados;<\/b><\/span><\/span><\/span><\/p>\n
      Quando criamos um arquivo de dados o que pretendemos \u00e9 gravar dados nele, e de forma organizada para pesquisarmos esses dados futuramente. <\/span><\/span><\/span><\/p>\n
      *Nota \u2013 Daqui em diante, ocasionalmente, poderei usar o termo bd para dizer ‘banco de dados’ ou o ‘arquivo do banco de dados’!<\/i><\/span><\/span><\/span><\/p>\n
      Para colocarmos dados no bd de modo organizados criamos tabelas, uma esp\u00e9cie de estrutura que lembra um prateleira com v\u00e1rias colunas e divis\u00f5es horizontais(linhas), para cada coluna criada devemos colocar o tipo de dado correspondente. Para melhor visualizarmos, observe o exemplo abaixo:<\/span><\/span><\/span><\/p>\n
      tabela clientes:<\/span><\/span><\/span><\/p>\n\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n
       
      \u00edndices<\/span><\/span><\/td>\nNOME <\/span><\/span><\/td>\nENDERE\u00c7O<\/span><\/span><\/td>\nTELEFONE<\/span><\/span><\/td>\n<\/tr>\n
      1<\/span><\/span><\/td>\nPaulo Martins<\/span><\/span><\/td>\nRua das Gra\u00e7as<\/span><\/span><\/td>\n99 9999 99999<\/span><\/span><\/td>\n<\/tr>\n
      2<\/span><\/span><\/td>\nEdmara Silva<\/span><\/span><\/td>\nRua dos Diamantes<\/span><\/span><\/td>\n66 6666 66666<\/span><\/span><\/td>\n<\/tr>\n
      3<\/span><\/span><\/td>\nPedro Alc\u00e2ntara<\/span><\/span><\/td>\nRua Eldorado<\/span><\/span><\/td>\n55 5555 55555<\/span><\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Veja que a tabela acima \u00e9 como uma prateleira com quatro colunas cada uma para guardar um dado espec\u00edfico. A primeira s\u00e3o os \u00edndices da sequ\u00eancia, a segunda coluna somente nomes, a terceira o endere\u00e7o e a quarta os n\u00fameros de telefones. Assim os dados ficam organizados, n\u00e3o podemos trocar, por exemplo, colocar nomes terceira ou quarta coluna, pois os dados ficariam desorganizados.<\/span><\/span><\/span><\/p>\n
      \u00c9 claro que num banco de dados as tabelas n\u00e3o ser\u00e3o visualmente como no exemplo acima, mas o modo de acess\u00e1-las ser\u00e1 de forma similar, em linhas e colunas. Por exemplo, poder\u00edamos acessar ‘Edmara Silva’ direcionando a pesquisa para segunda coluna na linha 2; ou seu telefone na coluna 4 e linha 2;<\/span><\/span><\/span><\/p>\n
      *Nota \u2013 Dentro de um mesmo bd podemos criar in\u00fameras tabelas e dentro destas tabelas podemos colocar bem mais de um dado.<\/i><\/span><\/span><\/span><\/p>\n
      Entendido um pouco sobre o que s\u00e3o tabelas, vamos aos c\u00f3digos:<\/span><\/span><\/span><\/p>\n
      Salve como tabela_insere_dados.prisma<\/span><\/span><\/span><\/p>\n
      \u00a0<\/span><\/span><\/span><\/span><\/p>\n
      local sql = inclua'sqlite3'\r\n\r\nret , base = sql.abra('teste.bd');\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia(); \/\/deixa o programa em erro fatal.\r\n\r\nfim\r\n\r\nstr_exec = [[\r\n\r\nDROP TABLE IF EXISTS amigos;\r\n\r\nCREATE TABLE amigos(Id INT, Nome TEXT, Idade INT);\r\n\r\nINSERT INTO amigos VALUES(1, 'Marcos', 52);\r\n\r\nINSERT INTO amigos VALUES(2, 'Maria', 19);\r\n\r\nINSERT INTO amigos VALUES(3, 'Pricila', 9);\r\n\r\n]];\r\n\r\nret , erro_msg = sql.exec(base, str_exec );\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"ERRO:\", erro_msg);\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Tabela criada e dados inseridos com sucesso\\n\");\r\n\r\nfim\r\n\r\nsql.feche(base);\r\n\r\nleia(); \/\/para n\u00e3o fechar abruptamente no windows.<\/pre>\n
      Detalhes:<\/p>\n
      Vamos pular o que j\u00e1 foi explicado nos exemplos anteriores, ok!<\/span><\/span><\/span><\/span><\/p>\n
      str_exec = [[\r\n\r\nDROP TABLE IF EXISTS amigos;\r\n\r\nCREATE TABLE amigos(Id INT, Nome TEXT, Idade INT);\r\n\r\nINSERT INTO amigos VALUES(1, 'Marcos', 52);\r\n\r\nINSERT INTO amigos VALUES(2, 'Maria', 19);\r\n\r\nINSERT INTO amigos VALUES(3, 'Pricila', 9);\r\n\r\n]];<\/pre>\n
       <\/p>\n
      Este trecho acima \u00e9 uma string de v\u00e1rias linhas em prisma contendo os comandos do sqlite3 (linguagem SQL); logo para usar o sqlite3 precisamos usar sua linguagem. Aqui passarei o b\u00e1sico.<\/span><\/span><\/span><\/p>\n
      *Nota \u2013 \u00c9 bom usar duplos colchetes de strings multilinhas ( [[ \u2026 ]] ) pois precisamos usar aspas internas. <\/i><\/span><\/span><\/span><\/p>\n
      Vamos detalhar os comandos sqlite3 acima:<\/span><\/span><\/span><\/p>\n
      DROP TABLE IF EXISTS amigos; <\/b><\/i><\/span><\/span><\/span><\/p>\n
      Cuidado! Este trecho apaga totalmente a tabela amigos com seus dados se ela j\u00e1 existir. <\/span><\/span><\/span><\/p>\n
      CREATE TABLE amigos(Id INT, Nome TEXT, Idade INT); <\/b><\/i><\/span><\/span><\/span><\/p>\n
      O comando acima significa: CRIE TABELA\u00a0<\/b><\/b>(CREATE TABLE) <\/b>amigos <\/b>e entre par\u00eanteses s\u00e3o passados os nomes das colunas e o tipo de dados ap\u00f3s os nomes:<\/span><\/span><\/span><\/p>\n
      Id (letra i maiuscula e d)<\/b> \u00e9 do tipo INT <\/b>(inteiro \u2013 n\u00famero sem casas decimais)<\/span><\/span><\/span><\/p>\n
      Nome<\/b> \u00e9 do tipo TEXT<\/b> (‘string entre aspas simples’);<\/span><\/span><\/span><\/p>\n
      Idade<\/b> \u00e9 do tipo INT<\/b> tamb\u00e9m, igual ao primeiro.<\/span><\/span><\/span><\/p>\n
      *Note que a linguagem sqlite3 segue uma sintaxe (regras) e cada comando termina com ponto e v\u00edrgula.<\/i><\/span><\/span><\/span><\/p>\n
      Observe que ao criar uma tabela, somos obrigados desde j\u00e1 a definir o n\u00famero, tipo e nome das colunas podendo ser modificados posteriormente com fun\u00e7\u00f5es do sqlite.<\/span><\/span><\/span><\/p>\n
      INSERT INTO amigos VALUES(1, ‘Marcos’, 52); <\/b><\/i><\/span><\/span><\/span><\/p>\n
      Aqui inserimos (INSERT) dentro (INTO) da tabela amigos<\/strong> os valores (VALUES): ( 1 , ‘Marcos’ , 52 );<\/span><\/span><\/span><\/p>\n
      *note que o nome est\u00e1 entre apas simples pois \u00e9 do tipo texto.<\/i><\/span><\/span><\/span><\/p>\n
      *Note que entre par\u00eanteses os valores s\u00e3o postos na mesma ordem de cria\u00e7\u00e3o das colunas da tabela.<\/i><\/span><\/span><\/span><\/p>\n
      E os demais comandos fazem a mesma coisa, s\u00f3 trocando os valores:<\/span><\/span><\/p>\n
      INSERT INTO amigos VALUES(2, ‘Maria’, 19); <\/b><\/i><\/span><\/span><\/p>\n
      INSERT INTO amigos VALUES(3, ‘Pricila’, 9); <\/b><\/i><\/span><\/span><\/span><\/p>\n
      Ap\u00f3s criar uma string de comandos sqlite3 podemos execut\u00e1-la com a fun\u00e7\u00e3o abaixo:<\/span><\/span><\/span><\/p>\n
      ret , erro_msg = sql.exec(base, str_exec ); <\/b><\/span><\/span><\/span><\/p>\n
      Esta fun\u00e7\u00e3o recebe 3 par\u00e2metros:<\/span><\/span><\/span><\/p>\n
       1 \u2013 vari\u00e1vel do banco de dados.<\/span><\/span><\/span><\/p>\n
      2 \u2013 a string de comandos sqlite3.<\/span><\/span><\/span><\/p>\n
      3 \u2013 foi omitido, ele \u00e9 opcional, trataremos adiante.<\/span><\/span><\/span><\/p>\n
      Com isso a string \u00e9 executada, a tabela \u00e9 criada (antes apagada se j\u00e1 existir) e os dados s\u00e3o inseridos.<\/span><\/span><\/span><\/p>\n
      E retorna 2 valores:<\/span><\/span><\/span><\/p>\n
      1 \u2013 ret<\/b> \u00e9 o n\u00famero que descreve \u00eaxito caso seja zero (sql.SQLITE_OK) ou erro caso seja qualquer outro n\u00famero.<\/span><\/span><\/span><\/p>\n
      2 \u2013 erro_msg<\/b> \u00e9 uma string que descreve o erro caso haja um.<\/span><\/span><\/span><\/p>\n
      Os outros comandos do exemplo s\u00e3o parecidos com o anterior, e j\u00e1 foi explicado!<\/span><\/span><\/span><\/p>\n
      Outro exemplo de inser\u00e7\u00e3o de dados no mesmo bd:<\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/i><\/span><\/span><\/span><\/p>\n
      sql = inclua 'sqlite3'; \/\/incluindo a biblioteca sqlite3\r\n\r\nret , base = sql.abra('teste.bd');\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nfim\r\n\r\nstr_exec = [[\r\n\r\nDROP TABLE IF EXISTS Carros;\r\n\r\nCREATE TABLE Carros(Id INT, Nome TEXT, Preco INT);\r\n\r\nINSERT INTO Carros VALUES(1, 'Audi', 52642);\r\n\r\nINSERT INTO Carros VALUES(2, 'Mercedes', 57127);\r\n\r\nINSERT INTO Carros VALUES(3, 'Skoda', 9000);\r\n\r\nINSERT INTO Carros VALUES(4, 'Volvo', 29000);\r\n\r\nINSERT INTO Carros VALUES(5, 'Bentley', 350000);\r\n\r\nINSERT INTO Carros VALUES(6, 'Citroen', 21000);\r\n\r\nINSERT INTO Carros VALUES(7, 'Hummer', 41400);\r\n\r\nINSERT INTO Carros VALUES(8, 'Volkswagen', 21600);\r\n\r\n]];\r\n\r\nret , erro_msg = sql.exec(base, str_exec );\r\n\r\nimprima(erro_msg);\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"SQL error:\", erro_msg);\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Tabela criada e dados inseridos com sucesso\\n\");\r\n\r\nfim\r\n\r\nsql.feche(base); \/\/fechado a base de dados.\r\n\r\nleia();<\/pre>\n
       <\/p>\n
      4 – ler e mostrar os dados;<\/b><\/i><\/span><\/span><\/span><\/p>\n
      4.1 lendo uma tabela completa<\/b><\/i><\/span><\/span><\/span><\/p>\n
      Salve como ler_tabela.prisma <\/span><\/span><\/span><\/p>\n
      \u00a0<\/span><\/span><\/span><\/p>\n
      local sql = inclua'sqlite3'\r\n\r\nret , base = sql.abra(\"teste.bd\");\r\n\r\nse ret <> sql.SQLITE_OK entao \/\/se ret for diferente de SQLiTE_OK\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia(); \/\/deixa o programa em erro fatal.\r\n\r\nfim\r\n\r\nfuncao sql_call ( valores , nome_coluna )\r\n\r\nimprima( '*****************************************');\r\n\r\nimprima( nome_coluna[1] , nome_coluna[2] , nome_coluna[3] );\r\n\r\nimprima( valores[1] , valores[2] , valores[3] );\r\n\r\nfim\r\n\r\nret , erro_msg = sql.exec(base, \"SELECT * FROM Carros\" , \"sql_call( %s , %s )\" );\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"SQL error:\", erro_msg );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Base de dados aberta e executada com sucesso!\\n\");\r\n\r\nfim\r\n\r\nsql.feche(base); \/\/fechado a base de dados.\r\n\r\nleia();<\/pre>\n
      Veja o resultado:<\/p>\n
      \"\"
      \n<\/span><\/span><\/span><\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
      Detalhes do exemplo acima: (lembre-se, vamos pular o que j\u00e1 foi explicado nos exemplos anteriores)<\/span><\/span><\/span><\/p>\n
      \u00a0<\/span><\/span><\/span><\/p>\n
      funcao sql_call ( valores , nome_coluna )\r\n\r\nimprima( '*****************************************');\r\n\r\nimprima( nome_coluna[1] , nome_coluna[2] , nome_coluna[3] );\r\n\r\nimprima( valores[1] , valores[2] , valores[3] );\r\n\r\nfim<\/pre>\n
       <\/p>\n
      \u00a0<\/span><\/span><\/span><\/p>\n
      Lembra do 3 par\u00e2metro omitido no exemplo anterior? Certo, precisamos dele agora, \u00e9 a fun\u00e7\u00e3o de retorno acima. Para criar essa fun\u00e7\u00e3o n\u00e3o h\u00e1 segredos, \u00e9 uma fun\u00e7\u00e3o prisma normal, com o nome que preferir, os par\u00e2metros principais s\u00e3o dois os valores e nomes das colunas. <\/span><\/span><\/span><\/p>\n
      O que acontece \u00e9 que ao usar a fun\u00e7\u00e3o sql.exec(), esta percorrer\u00e1 cada linha da tabela executando a fun\u00e7\u00e3o de retorno e passando os valores e nomes de colunas de cada linha precorrida.<\/span><\/span><\/span><\/p>\n
      *Note que valores e nome_coluna s\u00e3o tabelas prisma contendo os dados da tabela sqlite3. No caso, como criamos tr\u00eas colunas na tabela Carros usamos 3 \u00edndices para acessar os dados de valores e nome_coluna.<\/i><\/span><\/span><\/span><\/p>\n
      ret , erro_msg = sql.exec(base, “SELECT * FROM Carros” <\/span>, “sql_call( %s , %s )”<\/span> ); <\/b><\/span><\/span><\/span><\/p>\n
      Esta \u00e9 a fun\u00e7\u00e3o que executa a string sqlite3; <\/span><\/span><\/span><\/p>\n
      Algumas novidades aqui:<\/span><\/span><\/span><\/p>\n
      1 \u2013 passamos diretamente a string de comando sqlite3 dentro do par\u00eanteses. (tanto faz, por vari\u00e1vel ou diretamente)<\/span><\/span><\/span><\/p>\n
      2 \u2013 usamos o terceiro par\u00e2metro, omitido nos exemplos anteriores.<\/span><\/span><\/span><\/p>\n
      Vamos entender aqui o comando sqlite3.<\/span><\/span><\/span><\/p>\n
      “SELECT * FROM Carros”<\/span><\/b> \u2013 pode ser lido como: selecione tudo (*) o que estiver (from) na tabela Carros.<\/span><\/span><\/span><\/p>\n
      “sql_call( %s , %s )” <\/span><\/b>\u2013 para passar a fun\u00e7\u00e3o de retorno (call back) como par\u00e2metro usamos uma string como se f\u00f4ssemos utilizar a fun\u00e7\u00e3o executestring(); pois internamente, a biblioteca igsqlite3 usa essa fun\u00e7\u00e3o.<\/span><\/span><\/span><\/p>\n
      E os dois ‘%s<\/strong>‘ dentro do par\u00eanteses? Eles s\u00e3o necess\u00e1rios pois s\u00e3o caracteres de formata\u00e7\u00e3o que ser\u00e3o substitu\u00eddos pelos par\u00e2metros valores e nome_colunas<\/strong> a cada linha da tabela. N\u00e3o se preocupe apenas utilize-os sempre!<\/span><\/span><\/span><\/p>\n
      Como explicado anteriormente essa fun\u00e7\u00e3o retorna dois valores, o n\u00famero e a mensagem de erro.<\/b><\/span><\/span><\/span><\/p>\n
      Quando essa fun\u00e7\u00e3o acima \u00e9 executada, ela executa o comando sqlite3 \u201cSELECT * FROM Carros\u201d e faz um loop (repeti\u00e7\u00e3o) passando cada linha dessa tabela selecionada at\u00e9 chegar a \u00faltima, isso acontece pois usamos o * que significa todos as linhas da tabela.<\/span><\/span><\/span><\/p>\n
      E se em vez de querer apenas imprimir os dados eu quisesse manipul\u00e1-los. Muito simples crie uma tabela prisma e passe todos os dados para ela usando a fun\u00e7\u00e3o de retorno. <\/b><\/span><\/span><\/span><\/p>\n
      Veja um exemplo abaixo:<\/b><\/span><\/span><\/span><\/p>\n
      \u00a0<\/span><\/span><\/span><\/p>\n
      \/**\r\n\r\n* Exemplo igsqlite3: obtendo e imprimindo os dados\r\n\r\n*\r\n\r\n* **\/\/\r\n\r\nlocal sql = inclua 'sqlite3'; \/\/incluindo a biblioteca sqlite3\r\n\r\n\/\/abrindo uma base de dados chamada teste.base\r\n\r\nret , base = sql.abra(\"teste.bd\");\r\n\r\nse ret <> sql.SQLITE_OK entao \/\/se ret for diferente de SQLiTE_OK\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia(); \/\/deixa o programa em erro fatal.\r\n\r\nfim\r\n\r\n\/\/funcao call back\r\n\r\ndados = {}; \r\ndados[0] = nulo\/\/para evitar erros no windows.\r\n\r\ncont = 1;\r\n\r\nfuncao sql_call ( msg , valores , nome_coluna )\r\n\r\ndados[cont] = {};\r\n\r\npara i = 1 , #valores inicio\r\n\r\ndados[cont][nome_coluna[i] ] = valores[i] ; \/\/dados[1].coluna = valor\r\n\r\nfim\r\n\r\ncont = cont + 1;\r\n\r\nfim\r\n\r\n\/\/a funcao exec executa a string de comando SQL = str_exec acima.\r\n\r\nret , erro_msg = sql.exec(base, \"SELECT * FROM Carros\" , \"sql_call( nulo , %s , %s )\" );\r\n\r\nse ret <> sql.SQLITE_OK entao \/\/se nao for igual a sucesso \u00e9 erro.\r\n\r\nimprima( \"SQL error:\", erro_msg );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Base de dados aberta e executada com sucesso!\\n\");\r\n\r\nfim\r\n\r\n\/\/imprimindo a tabela:\r\n\r\npara i = 1 , #dados inicio\r\n\r\nimprima('\\n************************************');\r\n\r\nimprima( 'id: ' .. dados[i].Id .. ' | Marca: ' .. dados[i].Nome .. ' | Pre\u00e7o: ' .. dados[i].Preco );\r\n\r\nfim\r\n\r\nsql.feche(base); \/\/fechado a base de dados.\r\n\r\n\/\/criando uma janelinha com listagem mostrando os dados:\r\n\r\ninclua'igbr'\r\n\r\njan = ig.janela('Mostre dados' , 250 , 200 );\r\n\r\nig.janela_def_posicao( jan , ig.janela_pos_centro);\r\n\r\nig.conecte(jan, ig.destruido , 'sis.saia(0)' ); \/\/necess\u00e1rio este comando para evitar erros no windows.\r\n\r\nv = ig.caixavertical(falso , 0 );\r\n\r\nig.ad( jan , v);\r\n\r\nlistagem = ig.listagem_com_titulos ('Id', 'Marca' , 'Pre\u00e7o' );\r\n\r\nig.listagem_def_largura_coluna ( listagem , 2 , 100 );\r\n\r\nig.ad( v , listagem );\r\n\r\nig.componente_modifique_fonte ( listagem , \"Arial\", ig.negrito, 11); \/\/define a fonte da listagem\r\n\r\nig.listagem_def_tipo_sombra( listagem , ig.sombra_riscado_dentro ); \/\/define o estilo de borda\r\n\r\n\/\/tente ig.sombra_dentro, ig.sombra_fora, ig.sombra_riscado_fora, execute e veja o resultado.\r\n\r\npara i = 1 , #dados inicio\r\n\r\nig.listagem_anexe ( listagem , dados[i].Id , dados[i].Nome , dados[i].Preco );\r\n\r\nse i % 2 == 0 entao \/\/se i for par\r\n\r\ncor = ig.cor_analise( ig.cinza ); \/\/definindo uma cor para letra\r\n\r\nig.listagem_def_cor_fundo( listagem , i , cor );\r\n\r\nfim \/\/se i % 2\r\n\r\nfim\r\n\r\n\/\/call back do box de listagem\r\n\r\n\/\/funcao que sera conectada ao box de listagem:\r\n\r\nfuncao list_exec ( comp , lin , col , evento )\r\n\r\nlocal id = ig.listagem_obt_texto(comp, lin, 1 );\r\n\r\nlocal Marca = ig.listagem_obt_texto(comp, lin, 2 );\r\n\r\nlocal Preco = ig.listagem_obt_texto(comp, lin, 3 );\r\n\r\ntexto2 = \"id = \" .. id .. '\\nMarca: ' .. Marca .. '\\nPre\u00e7o: ' .. Preco;\r\n\r\nig.msg( janela , 'Listagem' , texto2 );\r\n\r\nfim\r\n\r\nig.conecte_funcao( listagem , ig.clique_linha , list_exec );\r\n\r\n\/\/note que o s do %s \u00e9 minusculo, senao causa um erro impercept\u00edvel para o debug.\r\n\r\nig.componente_mostre_todos(jan);\r\n\r\nig.fimprograma();<\/pre>\n
      Sa\u00edda:<\/p>\n
      \"\"
      \n<\/span><\/span><\/span><\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
      Para o ambiente gr\u00e1fico foi usado a biblioteca ‘igbr’. No site oficial prisma h\u00e1 v\u00e1rios exemplos na se\u00e7\u00e3o p\u00e1gina de posts.<\/span><\/span><\/span><\/p>\n
      4.2 lendo uma <\/b><\/i>linha <\/b><\/i>espec\u00edfic<\/b><\/i>a<\/b><\/i> da tabela:<\/b><\/i><\/span><\/span><\/span><\/p>\n
      S<\/b><\/i>alve como ler_linha.prisma<\/b><\/i><\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/span><\/span><\/span><\/p>\n
      local sql = inclua'sqlite3';\r\n\r\nret , base = sql.abra(\"teste.bd\");\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima(\"Erro: \", sql.mensagem_erro(base));\r\n\r\nsql.feche(base);\r\n\r\nfim\r\n\r\nstr_exec = \"SELECT Id, Nome , Preco FROM Carros WHERE Id = 3\";\r\n\r\nfuncao sql_func(valor,coluna)\r\n\r\nimprima('++++++++++++++++++++++');\r\n\r\nimprima( coluna[1] , coluna[2] , coluna[3]);\r\n\r\nimprima( valor[1] , valor[2] , valor[3] );\r\n\r\nimprima('++++++++++++++++++++++');\r\n\r\nfim\r\n\r\nret , msg = sql.exec(base , str_exec , 'sql_func(%s,%s)' );\r\n\r\nsql.feche(base);\r\n\r\nleia();<\/pre>\n
      Vamos direto para as novidades aqui, comando sqlite3 novo:<\/span><\/span><\/span><\/p>\n
      str_exec = “SELECT Id, Nome , Preco FROM Carros WHERE Id = 3”<\/span>;<\/b><\/span><\/span><\/span><\/p>\n
      Pode ser entendido como: SELECIOME as colunas Id, Nome e Preco DA tabela Carros ONDE Id for igual a 3.<\/i><\/span><\/span><\/span><\/p>\n
      Ao ser executada essa string de comando sqlite3, ela procura pela linha onde a coluna Id for igual a 3 e retorna os valores para a fun\u00e7\u00e3o de retorno sql_func (); <\/span><\/span><\/span><\/p>\n
      funcao sql_func(valor,coluna)\r\n\r\nimprima('++++++++++++++++++++++');\r\n\r\nimprima( coluna[1] , coluna[2] , coluna[3]);\r\n\r\nimprima( valor[1] , valor[2] , valor[3] );\r\n\r\nimprima('++++++++++++++++++++++');\r\n\r\nfim<\/pre>\n
       <\/p>\n
      Esta fun\u00e7\u00e3o acima \u00e9 a fun\u00e7\u00e3o call back(retorno) que \u00e9 executada automaticamente pela sql.exec() e recebe os valores nome da coluna da tabela sqlite3 e seus dados em valor.<\/span><\/span><\/span><\/p>\n
      ret , msg = sql.exec(base , str_exec , ‘sql_func(%s,%s)’ ); <\/b><\/span><\/span><\/p>\n
      E, por fim, executamos a string de comando sqlite3, relembre que o terceiro par\u00e2metro \u00e9 a string da fun\u00e7\u00e3o de retorno par\u00eanteses e os dois %s que ser\u00e3o substitu\u00eddos pelos valores e colunas da tabela sqlite3.<\/span><\/span><\/p>\n
      *Nota \u2013 Veja que a fun\u00e7\u00e3o sql_func tem dois par\u00e2metros valor e coluna que s\u00e3o os %s passados para sql.exec. Esses dois valores s\u00e3o tabelas prisma e o n\u00famero de elementos depende do n\u00famero de colunas criadas na tabela sqlite3.<\/i><\/span><\/span><\/p>\n
      Este exemplo acima funciona bem como consulta de dados. Caso queira pegar os dados, em vez de simplesmente imprimi-los, use uma tabela prisma para isso, assim:<\/span><\/span><\/span><\/p>\n
       <\/p>\n
      local dados = { [0] = nulo }; \/\/evitar erros no windows.\r\nlocal cont = 1;\r\nfuncao sql_func(valor,coluna)\r\n\r\ndados[cont] = {}; \/\/cada \u00edndice da tabela acima tamb\u00e9m ser\u00e1 uma tabela\r\n\r\ndados[cont][coluna[1] ] = valor[1]; \/\/os campos ser\u00e3o os nomes das colunas, valor ser\u00e1 os valores.\r\n\r\ndados[cont] [coluna[2] ] = valor[2];\r\n\r\ndados[cont] [coluna[3] ] = valor[3];\r\n\r\ncont = cont + 1; \r\n\r\nfim\r\n<\/pre>\n
      N\u00e3o esque\u00e7a no final de usar o comando sis.saia(0) para evitar erro no Windows ap\u00f3s fechar o programa ou se estiver usando modulo igbr use: ig.conecte( janela, ig.destruido , ‘sis.saia(0)’ );<\/p>\n
      Pronto, agora podemos acessar os dados assim: dados.Id, dados.Nome , dados.Preco<\/span><\/span><\/span><\/p>\n
      Sa\u00edda do exemplo acima:<\/span><\/span><\/span><\/p>\n
      \"\"<\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
       <\/p>\n
      4.<\/b><\/i>3 Comandos parametrizados do sqlite3.<\/b><\/i><\/span><\/span><\/span><\/p>\n
      Comando sql.prepare_v2();<\/b><\/i><\/span><\/p>\n
      local sql = inclua'sqlite3';\r\nret , base = sql.abra(\"teste.bd\");\r\n\r\n    \r\n  se ret <> sql.SQLITE_OK entao\r\n        \r\n        imprima(\"Erro: \", sql.mensagem_erro(base));\r\n        sql.feche(base);\r\n  fim \/\/fim se ret <>\r\n\r\nsql_cmd = \"SELECT Id, Nome , Preco FROM Carros WHERE Id = ?\"\r\n    ret , res = sql.prepare_v2( base , sql_cmd );\r\n\r\n    se ret == sql.SQLITE_OK entao        \r\n        sql.vincule_int( res , 1, 4); \/\/vincula o valor 4 da tabela sql ao indice 1 \r\n   senao        \r\n        imprima( \"Falha na execucao: \" .. sql.mensagem_erro(base) );\r\n       leia();\r\n       sis.saia(0);\r\n    fim\r\n    \r\n    pas = sql.passe(res); \r\n    \r\n    se (pas == sql.SQLITE_LIN) entao       \r\n        imprima ( sql.coluna_texto( res , 1) .. ' : ' .. sql.coluna_texto(res, 2) .. ' : ' .. sql.coluna_texto(res, 3) );        \r\n    fim\r\n\r\n    sql.finalize(res); \r\n    sql.close(base);\r\n\r\nleia();\r\n<\/pre>\n
      Detalhes:<\/span><\/span><\/span><\/p>\n
      “SELECT Id, Nome , Preco FROM Carros WHERE Id = ?”;<\/b><\/span><\/span><\/span><\/p>\n
      Essa \u00e9 a string de comando sqlite. O ponto de interroga\u00e7\u00e3o ser\u00e1 substitu\u00eddo por um valor posteriormente.<\/span><\/span><\/span><\/p>\n
       ret , res = sql.prepare_v2( base , <\/b>sql_cmd<\/b> );<\/b><\/span><\/span><\/span><\/p>\n
      Este comando compila (prepara) a string sqlite3. Par\u00e2metros: 1- banco de dados aberto, 2- \u00e9 a string sqlite3. <\/span><\/span><\/span><\/p>\n
      Dois retornos:<\/b><\/span><\/span><\/span><\/p>\n
       ret <\/b>\u00e9 um n\u00famero que pode indicar \u00eaxito (zero) ou falha (qualquer outro n\u00famero); <\/span><\/span><\/span><\/p>\n
      res<\/b> \u00e9 a string sqlite j\u00e1 compilada.<\/span><\/span><\/span><\/p>\n
      sql.vincule_int( res , 1, 4); <\/b><\/span><\/span><\/span><\/p>\n
      Esta fun\u00e7\u00e3o coloca o valor 4 no lugar do \u201c?\u201d <\/b>dentro da string de comando sqlite. <\/span><\/span><\/span><\/p>\n
      Par\u00e2metros: 1 \u2013 string sqlite compilada, 2 \u2013 \u00edndice sqlite, 3 \u2013 n\u00famero que ficar\u00e1 no lugar do \u201c?\u201d;<\/b><\/span><\/span><\/span><\/p>\n
       pas = sql.passe(res); <\/b><\/span><\/span><\/span><\/p>\n
      A fun\u00e7\u00e3o sql.passe() analisa a string sqlite compilada e retorna uma linha se houver (pas); \u00fanico par\u00e2metro \u00e9 a string compilada.<\/span><\/span><\/span><\/p>\n
      se (pas == sql.SQLITE_LIN) entao <\/b> <\/span><\/span><\/span><\/p>\n
      A condi\u00e7\u00e3o testa se pas (retorno de sql.passe() ) \u00e9 um alinha sqlite v\u00e1lida.<\/span><\/span><\/span><\/p>\n
      sql.coluna_texto( res , 1)<\/b><\/span><\/span><\/span><\/p>\n
      Esta fun\u00e7\u00e3o retorna o valor da coluna 1 da tabela Carros. (Id)<\/span><\/span><\/span><\/p>\n
      sql.coluna_texto( res , 2) <\/b>retorna o valor da coluna 2; (Nome)<\/span><\/span><\/span><\/p>\n
      sql.coluna_texto( res , 3) <\/b>retorna o valor da coluna 3; (Preco);<\/span><\/span><\/span><\/p>\n
      Obs. Este m\u00e9todo, particularmente, tem um pequeno grau de complica\u00e7\u00e3o mas \u00e9 mais r\u00e1pido e seguro. <\/span><\/span><\/span><\/p>\n
      4.<\/b><\/i>3 Leitura de dados sqlite3. (N\u00e3o ocorre erro no Windows, comando mais confi\u00e1vel);<\/b><\/i><\/span><\/span><\/span><\/p>\n
      Lendo todos os dados da tabela:<\/b><\/i><\/span><\/span><\/span><\/p>\n
      local sql = inclua'igsqlite3';\r\nret , base = sql.abra(\"teste.bd\");\r\n\r\n    \r\n   se ret <> sql.SQLITE_OK entao\r\n        \r\n        imprima(\"Erro: \", sql.mensagem_erro(base));\r\n        sql.feche(base);\r\n  fim \/\/fim se ret <>\r\n   \r\n        \r\n    ret , res = sql.prepare_v2( base , \"SELECT * FROM Carros;\" ); \r\n\r\n   se ret <> sql.SQLITE_OK entao erro('Erro'); fim\r\n \r\n enquanto 1 inicio   \r\n    pas = sql.passe(res); \/\/executa a string compilada res.\r\n    \r\n    se (pas == sql.SQLITE_LIN) entao     \r\n        imprima( sql.coluna_nome(res, 1)  , sql.coluna_nome(res, 2) , sql.coluna_nome(res, 3) );  \r\n        imprima ( sql.coluna_texto( res , 1) .. ' : ' .. sql.coluna_texto(res, 2) .. ' : ' .. sql.coluna_texto(res, 3) ); \r\n    senao \r\n        quebre;       \r\n    fim\r\n    \r\n fim \/\/enquanto\r\n\r\n    sql.finalize(res); \/\/ **\/\/\r\n    sql.close(base);\r\n\r\nleia();<\/pre>\n
      “SELECT * FROM Carros;”<\/b><\/i><\/span><\/span><\/span><\/span><\/p>\n
      Esta \u00e9 a cl\u00e1usula sqlite, ela seleciona todos (*) os dados da (from) tabela Carros.<\/span><\/span><\/span><\/p>\n
      ret , res = sql.prepare_v2( base , “SELECT * FROM Carros;”<\/i><\/span> ); <\/b><\/span><\/span><\/span><\/p>\n
      Acima compilamos a cl\u00e1usula.<\/span><\/span><\/span><\/p>\n
      enquanto 1 inicio   \r\n    pas = sql.passe(res); \/\/executa a string compilada res.\r\n    \r\n    se (pas == sql.SQLITE_LIN) entao     \r\n        imprima( sql.coluna_nome(res, 1)  , sql.coluna_nome(res, 2) , sql.coluna_nome(res, 3) );  \r\n        imprima ( sql.coluna_texto( res , 1) .. ' : ' .. sql.coluna_texto(res, 2) .. ' : ' .. sql.coluna_texto(res, 3) ); \r\n    senao \r\n        quebre;       \r\n    fim\r\n    \r\n fim \/\/enquanto<\/pre>\n
      <\/b>*Nota \u2013 Baixe a vers\u00e3o mais atual de Prisma para a fun\u00e7\u00e3o sql.coluna_nome()<\/i><\/span><\/span><\/span><\/p>\n
      Depois de compilar a string sqlite podemos usar a fun\u00e7\u00e3o sql.passe(). <\/b>A cada repeti\u00e7\u00e3o dessa fun\u00e7\u00e3o uma linha da tabela \u00e9 percorrida. O retorno \u00e9 um c\u00f3digo de erro que pode indicar uma linha v\u00e1lida (sql.SQLITE_LIN que \u00e9 igual a 100) ou n\u00e3o. Caso seja uma linha v\u00e1lida \u00e9 poss\u00edvel obter os nomes das colunas com a fun\u00e7\u00e3o sql.coluna_nome()<\/b> e o valor das colunas com a fun\u00e7\u00e3o sql.coluna_texto().<\/b><\/span><\/span><\/span><\/p>\n
      Dica \u2013 use a fun\u00e7\u00e3o convnumero() caso queira converter de string para n\u00famero.<\/b><\/i><\/span><\/span><\/span><\/p>\n
       <\/p>\n
      5 \u2013 pegar o n\u00famero atual de registros id de uma tabela;<\/b><\/span><\/span><\/span><\/p>\n
      Muitas vezes podemos querer saber qual foi o id da \u00faltima linha inserida em uma tabela, para isto temos a fun\u00e7\u00e3o:<\/span><\/span><\/span><\/p>\n
       sql.ultimo_id( base );<\/b><\/i><\/span><\/span><\/span><\/p>\n
      Para essa fun\u00e7\u00e3o funcionar devemos usar um tipo de coluna chamado de chave de auto contagem ou auto incremento.<\/span><\/span><\/span><\/p>\n
      Nesse tipo de coluna n\u00e3o precisamos colocar seu valor 1, 2, 3, 4 \u2026 a contagem \u00e9 feita automaticamente. Veja abaixo:<\/span><\/span><\/span><\/p>\n
      Salve como ultimo_id.prisma<\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/span><\/span><\/span><\/p>\n
      sql = inclua 'sqlite3';\r\n\r\nret , base = sql.abra(sql.memoria);\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia(); \/\/deixa o programa em erro fatal.\r\n\r\nfim\r\n\r\nstr_exec = [[\r\n\r\nCREATE TABLE Amigos(Id INTEGER PRIMARY KEY, Nome TEXT, idade INT);\r\n\r\nINSERT INTO Amigos(Nome, idade) VALUES ('Tom', 15);\r\n\r\nINSERT INTO Amigos(Nome, idade) VALUES ('Rebecca', 34);\r\n\r\nINSERT INTO Amigos(Nome, idade) VALUES ('Jim', 44);\r\n\r\nINSERT INTO Amigos(Nome, idade) VALUES ('Roger', 23);\r\n\r\nINSERT INTO Amigos(Nome, idade) VALUES ('Robert', 32);\r\n\r\n]];\r\n\r\nret , erro_msg = sql.exec(base, str_exec );\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"SQL error:\", erro_msg);\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Tabela criada e dados inseridos com sucesso\\n\");\r\n\r\nfim\r\n\r\nult_id = sql.ultimo_id( base ); \/\/esta funcao pega o ultimo id primary key inserido na tabela.\r\n\r\nimprima( \"Ultima chave id da tabela Amigos \u00e9:\" , ult_id);\r\n\r\nsql.feche(base); \/\/fechado a base de dados.<\/pre>\n
      Novidades neste exemplo:<\/span><\/span><\/span><\/p>\n
      ret , base = sql.abra(sql.memoria);<\/b><\/span><\/span><\/span><\/p>\n
      Ao usar o comando acima com o par\u00e2metro sql.memoria um banco de dados ser\u00e1 criado na mem\u00f3ria, n\u00e3o haver\u00e1 nenhum arquivo.<\/span><\/span><\/span><\/p>\n
      str_exec = [[ <\/b><\/span><\/span><\/span><\/p>\n
       CREATE TABLE Amigos(Id INTEGER PRIMARY KEY, Nome VARCHAR(55), idade INT); <\/b><\/span><\/span><\/span><\/p>\n
       INSERT INTO Amigos(Nome, idade) VALUES (‘Tom’, 15); <\/b><\/span><\/span><\/span><\/p>\n
       INSERT INTO Amigos(Nome, idade) VALUES (‘Rebecca’, 34); <\/b><\/span><\/span><\/span><\/p>\n
       INSERT INTO Amigos(Nome, idade) VALUES (‘Jim’, 44); <\/b><\/span><\/span><\/span><\/p>\n
       INSERT INTO Amigos(Nome, idade) VALUES (‘Roger’, 23); <\/b><\/span><\/span><\/span><\/p>\n
       INSERT INTO Amigos(Nome, idade) VALUES (‘Robert’, 32); <\/b><\/span><\/span><\/span><\/p>\n
       ]];<\/b><\/span><\/span><\/span><\/p>\n
      Acima \u00e9 a string de comandos sqlite3. Podemos perceber nela a chave de auto contagem na cria\u00e7\u00e3o da tabela:<\/span><\/span><\/span><\/p>\n
      CREATE TABLE Amigos(Id INTEGER PRIMARY KEY, Nome VARCHAR(55), idade INT); <\/b><\/span><\/span><\/span><\/p>\n
      eis a chave:  Id INTEGER PRIMARY KEY, <\/b>ser\u00e1 sempre assim n\u00e3o a modifique.<\/span><\/span><\/span><\/p>\n
      A segunda coluna criada \u00e9 o Nome que \u00e9 do tipo VARCHAR(55) (uma string de no m\u00e1ximo 55 caracteres) e a terceira coluna \u00e9 idade do tipo INT (n\u00famero inteiro);<\/span><\/span><\/span><\/p>\n
      Veja que quando usamos uma chave (KEY) de auto contagem, devemos especificar o nome das colunas entre par\u1ec1nteses ao inserir os dados, deixando de fora a chave de auto contagem. Veja abaixo:<\/span><\/span><\/span><\/p>\n
      INSERT INTO Amigos(Nome, idade) VALUES (‘Tom’, 15); <\/b><\/span><\/span><\/span><\/p>\n
      E assim com os comandos restantes.<\/span><\/span><\/span><\/p>\n
       ult_id = sql.ultimo_id( base ); <\/b><\/span><\/span><\/span><\/p>\n
      Aqui pegamos o n\u00famero da \u00faltima chave (INTEGER PRIMARY KEY<\/b>), o retorno \u00e9 um n\u00famero prisma.<\/span><\/span><\/span><\/p>\n
      O resultado ser\u00e1 5 pois criamos somente 5 linhas no exemplo, mas pense em um arquivo com milhares de dados, esta fun\u00e7\u00e3o \u00e9 muito \u00fatil para inserir um novo dado sem correr o risco de errar a contagem.<\/span><\/span><\/span><\/p>\n
       <\/p>\n
      6 – pegar o nome de todas as tabelas existentes em um bd;<\/b><\/span><\/span><\/span><\/p>\n
      Algumas vezes n\u00f3s podemos querer descobrir quais tabelas est\u00e3o criadas em um bd, mas sem fazer ideia do nome delas. Para isso veja o exemplo abaixo:<\/span><\/span><\/span><\/p>\n
      Salve com o nome de nome_tabela.prisma<\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/span><\/span><\/span><\/p>\n
      local sql = inclua 'igsqlite3'; \/\/incluindo a biblioteca sqlite3\r\n\r\nret , base = sql.abra(\"Teste.bd\");\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( \"Erro:\" , sql.mensagem_erro(base) );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia(); \/\/deixa o programa em erro fatal.\r\n\r\nfim\r\n\r\ndados = {};\r\ndados[0] = nulo; \/\/atribua um valor qualquer para n\u00e3o dar erro no Win.\r\ncont = 1;\r\n\r\nfuncao sql_call ( valores , nome_coluna )\r\n\r\n  dados[cont] = {[0]=nulo};\r\n\r\n  dados[cont] = { nome_coluna[1], valores[1] }\r\n\r\n  cont = cont + 1;\r\n\r\nfim\r\n\r\nret , erro_msg = sql.exec(base, \"SELECT name FROM sqlite_master WHERE type='table';\" , \"sql_call( %s , %s )\" );\r\n\r\nse ret <> sql.SQLITE_OK entao \/\/se nao for igual a OK \u00e9 erro.\r\n\r\nimprima( \"SQL error:\", erro_msg );\r\n\r\nsql.feche(base);\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\nimprima(\"Base de dados aberta e executada com sucesso!\\n\");\r\n\r\nfim\r\n\r\n\/\/imprimindo a tabela:\r\n\r\npara i = 1 , #dados inicio\r\n\r\nimprima('\\n************************************');\r\n\r\nimprima( dados[i][1] , dados[i][2] );\r\n\r\nfim\r\n\r\nsql.feche(base); \/\/fechado a base de dados.<\/pre>\n
      Detalhes:<\/strong><\/span><\/p>\n
       <\/p>\n
      funcao sql_call ( valores , nome_coluna )\r\n\r\ndados[cont] = {[0] = nulo};\r\n\r\ndados[cont] = { nome_coluna[1], valores[1] }\r\n\r\ncont = cont + 1;\r\n\r\nfim<\/pre>\n
       <\/p>\n
      Acima est\u00e1 a fun\u00e7\u00e3o de retorno (call back);<\/span><\/span><\/span><\/p>\n
      A novidade aqui \u00e9 o comando sqlite3 que permite selecionar o nome de todas as tabelas do bd:<\/span><\/span><\/span><\/p>\n
      “SELECT name FROM sqlite_master WHERE type=’table’;” <\/b><\/span><\/span><\/span><\/p>\n
      Leia: SELECIONE name de sqlite_master ONDE o tipo for ‘tabela’; <\/span><\/span><\/span><\/p>\n
      sqlite_master \u00e9 uma esp\u00e9cie de cabe\u00e7alho de informa\u00e7\u00f5es do bd.<\/span><\/span><\/span><\/p>\n
      Este comando sqlite3 \u00e9 passado como segundo par\u00e2metro na fun\u00e7\u00e3o abaixo:<\/span><\/span><\/span><\/p>\n
      sql.exec(base, “SELECT name FROM sqlite_master WHERE type=’table’;” , “sql_call( %s , %s )” ); <\/b><\/span><\/span><\/span><\/p>\n
      Que ao ser executado, executa tamb\u00e9m a fun\u00e7\u00e3o call back passando os dados selecionados no comando sqlite3.<\/span><\/span><\/span><\/p>\n
      7 – deletar e atualizar os dados de uma tabela;<\/b><\/span><\/span><\/span><\/p>\n
      7.1 Apagando uma linha da tabela:<\/b><\/span><\/span><\/span><\/p>\n
      Deletar uma linha \u00e9 simples, veja o exemplo abaixo:<\/span><\/span><\/span><\/p>\n
      salve como deleta.prisma<\/span><\/span><\/span><\/p>\n
      \u00a0<\/b><\/span><\/span><\/span><\/p>\n
      local sql = inclua'sqlite3'\r\n\r\nlocal xstr = [[\r\n\r\nDELETE from Carros where Id = 2;\r\n\r\n]];\r\n\r\nfuncao exec() fim;\r\n\r\nlocal ret , base = sql.abra('Teste.bd');\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\npoe('Erro ao abrir banco de dados');\r\n\r\nsis.saia();\r\n\r\nfim\r\n\r\nlocal ret , erro_msg = sql.exec(base, xstr , \"exec()\" );\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\npoe('Erro: ' .. erro_msg );\r\n\r\nsis.saia();\r\n\r\nsenao\r\n\r\npoe'dado deletado com sucesso';\r\n\r\nfim\r\n\r\nleia();<\/pre>\n
      A novidade neste exemplo \u00e9 o comando sqlite3 para deletar uma linha a partir de um id:<\/span><\/span><\/span><\/p>\n
      DELETE from Carros where Id = 2;<\/b><\/span><\/span><\/span><\/p>\n
      Leia: Apague de carros a linha onde o id for igual a 2;<\/span><\/span><\/span><\/p>\n
      Para apagar todos os dados da tabela use:<\/span><\/span><\/span><\/p>\n
      DELETE from Carros;<\/b><\/span><\/span><\/span><\/p>\n
      Para apagar completamente uma tabela:<\/span><\/span><\/span><\/p>\n
      DROP TABLE IF EXISTS Carros;<\/b><\/span><\/span><\/span><\/p>\n
       <\/p>\n
      7.2 Atualizando um dado da tabela:<\/b><\/span><\/span><\/span><\/p>\n
      Salve o programa como atualiza_bd.prisma<\/b><\/span><\/span><\/span><\/p>\n
      \u00a0<\/span><\/span><\/span><\/span><\/p>\n
      local sql = inclua'sqlite3';\r\n\r\nret , bd = sql.abra('teste.bd');\r\n\r\nse ret <> sql.SQLITE_OK entao\r\n\r\nimprima( 'erro ao tentar abrir banco de dados, ENTER para sair');\r\n\r\nleia();\r\n\r\nsis.saia();\r\n\r\nfim\r\n\r\nsql_str = [[ UPDATE Carros set Nome = 'NADA_AQUI' where Id = 1;\r\n\r\nSELECT * from Carros; ]];\r\n\r\nfuncao sql_func(v , col)\r\n\r\npara i = 1 , #v inicio\r\n\r\nimprima( col[i] , v[i] );\r\n\r\nfim\r\n\r\nfim\r\n\r\nret, msg = sql.exec(bd , sql_str , 'sql_func(%s,%s)' );\r\n\r\nse ret == 0 entao imprima(\"sucesso!!!\");\r\n\r\nsenao imprima(\"Erro\" , msg );\r\n\r\nfim\r\n\r\nleia();<\/pre>\n
      Detalhes:<\/b><\/span><\/span><\/span><\/p>\n
      O comando sqlite3 para atualizar um dado \u00e9:<\/span><\/span><\/span><\/span><\/p>\n
      [[ UPDATE Carros set Nome = ‘NADA_AQUI’ where Id = 1; ]]<\/b><\/span><\/span><\/span><\/p>\n
      Leia-se ATUALIZE Carros defina Nome igual a ‘NADA_AQUI’ onde o Id for igual a 1;<\/span><\/span><\/span><\/p>\n
      basta executar essa string e a linha que tiver o id 1 na coluna Nome ser\u00e1 trocado o valor por ‘NADA AQUI’;<\/span><\/span><\/span><\/p>\n
      Obs. para mudar o valor de outras linhas troque o Id = 1 por Id = 2; ou 3, 4, 5 etc.<\/span><\/span><\/span><\/p>\n
      Para mudar n\u00e3o s\u00f3 a coluna nome mas outras colunas tamb\u00e9m basta acrescentar na mesma string sqlite3 o nome das outras colunas, assim:<\/b><\/i><\/span><\/span><\/span><\/p>\n
      [[ UPDATE Carros set Nome = ‘NADA_AQUI’ , Preco = 77777 where Id = 1; ]]<\/b><\/span><\/span><\/span><\/p>\n
      Veja que ao acrescentar mais uma coluna devemos separ\u00e1-la por virgula.<\/span><\/span><\/span><\/p>\n
      [[ SELECT * from Carros; ]]<\/b><\/span><\/span><\/span><\/p>\n
      Este outro comando na mesma string sqlite3 serve para selecionar a tabela Carros para imprimirmos o valor modificado.<\/span><\/span><\/span><\/p>\n
      O comando sqlite3 completo acima com mais uma coluna para modificar o valor fica:<\/span><\/span><\/span><\/p>\n
      sql_str = [[\r\n\r\nUPDATE Carros set Nome = 'NADA_AQUI' , Preco = 77777 where Id = 1;\r\n\r\nSELECT * from Carros;\r\n\r\n]];<\/pre>\n
       <\/p>\n
      Executando essa string:<\/span><\/span><\/span><\/p>\n
      ret, msg = sql.exec(bd , sql_str , ‘sql_func(%s,%s)’ ); <\/b><\/span><\/span><\/p>\n
      *Note que a string ficou atribu\u00edda na vari\u00e1vel sql_str e passada como argumento na fun\u00e7\u00e3o sql.exec.<\/i><\/span><\/span><\/span><\/p>\n
      Dicas finais:<\/b><\/span><\/span><\/span><\/p>\n
      *Veja que \u00e9 simples executar um comando sqlite usando a fun\u00e7\u00e3o sql.exec();<\/b><\/span><\/span><\/span><\/p>\n
      *Aqui explanei o b\u00e1sico, mas voc\u00ea pode facilmente aprender novos comandos sqlite e executar.<\/b><\/span><\/span><\/span><\/p>\n
      *Voc\u00ea pode salvar os comandos sqlite em um texto e usar a fun\u00e7\u00e3o de leitura de arquivo para obter o conte\u00fado em uma string e execut\u00e1-la.<\/b><\/span><\/span><\/span><\/p>\n
      Qualquer d\u00favida:<\/b><\/span><\/span><\/span><\/p>\n
      Visite o site: linguagemprisma.br4.biz ou o f\u00f3rum (link no site)<\/b><\/span><\/span><\/span><\/p>\n
      At\u00e9 logo;<\/b><\/span><\/span><\/span><\/p>\n
      Att. Adalberto.<\/b><\/span><\/span><\/span><\/p>\n
      Fim<\/b><\/i><\/span><\/span><\/span><\/p>\n
      \"\"<\/p>\n","protected":false},"excerpt":{"rendered":"
      TUTORIAL SQLITE3 PRISMA Por Adalberto   Link para a lista de fun\u00e7\u00f5es sqlite3 Prisma.   Nota: Problemas no Win resolvidos, releia a parte 4,\u00a0exemplo\u00a0j\u00e1 modificado. Eu, pessoalmente recomendo muito o Linux, especialmente o Ubuntu. Pode acreditar, vai evitar tremendas dores de cabe\u00e7a, inclusive se for correr um servidor nele. Requisitos m\u00ednimos: instala\u00e7\u00e3o completa prisma-1.0 mais…<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"tpl-full-width.php","meta":{"footnotes":""},"class_list":["post-2407","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/pages\/2407","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/comments?post=2407"}],"version-history":[{"count":24,"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/pages\/2407\/revisions"}],"predecessor-version":[{"id":2486,"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/pages\/2407\/revisions\/2486"}],"wp:attachment":[{"href":"https:\/\/linguagemprisma.br4.biz\/blog\/wp-json\/wp\/v2\/media?parent=2407"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}