Jump to content

Manimal

Administradores (Adm)
  • Content count

    526
  • Joined

  • Last visited

  • Days Won

    66

Everything posted by Manimal

  1. Humm, então é por isso. Faz sentido. Belini, por questões pessoais, ainda usa uma versão mais antiga do AutoIt. Agora funcionou o exemplo.
  2. Show de bola! Agora deu boa. Parabéns!
  3. Criar e ler um banco de dados SQlite

    Olá. Eu pessoalmente sou muito fã de expressões regulares, mas eu acredito que neste caso, ela ficaria muito lenta. Um LIKE ficaria mais rápido, não?
  4. Como assim, flickers? Flickers são exatamente falha de vídeo, pois a frequencia de exibição está muito alta ou muito baixa. Quando vc fala em controlar a frequencia é exatamente para evitar o flicker. Neste caso, vc setou em 20ms, o que provavelmente na sua máquina não "flicka", mas é interessante testar em outras, para ter certeza do valor. E vc percebeu que o GIF tem o tamanho de 300x300, mas a janela que vc abriu tem 100x100? Quando falamos em redimensionar para caber, um GIF não é uma imagem estática que é facilmente ajustada pelo tamanho, inclusive tem várias técnicas para determinar a menor perda de qualidade no redimensionamento. Um GIF é basicamente um filminho, ou seja, para redimensionar para caber cada frame deve ser extraído, redimensionado e reinserido no GIF, e não vejo nenhuma função fazendo isso. Talvez, como a função é bem detalhada, colocar uma função de redimensionamento no meio dela, poderia funcionar. Especificamente, neste GIF que vc enviou junto são 3 imagens de 300x300. Eu mudei o tamanho para 100x100. Veja se serve.
  5. Está dando erro na variável ghGDIPDll Provavelmente, vc esqueceu de "abrir" a DLL adequada a ser armazenada em ghGDIPDll
  6. Olá Belini. Achei que vc já tivesse alguma. Segue a que eu uso. Só precisa ajustar o tamanho da janela ao tamanho do gif (se necessário). #include <GUIConstants.au3> #include "GIFAnimation.au3" #include <FileConstants.au3> #include <WindowsConstants.au3> Local $sPastaDestino = @ScriptDir, $sArquivoGIF = "\Hello.gif" If @Compiled Then $sPastaDestino = @TempDir FileInstall(@ScriptDir & $sArquivoGIF, $sPastaDestino & $sArquivoGIF, $FC_OVERWRITE) Else If not FileExists($sPastaDestino & $sArquivoGIF) Then ConsoleWrite("GIF não existe" & @CRLF) Exit EndIf EndIf Local $hWnd_Janela = GUICreate("Atualizando multimídia...", 220, 206, -1, -1, $WS_EX_TOOLWINDOW) Local $hGIF = _GUICtrlCreateGIF($sPastaDestino & $sArquivoGIF, "", 0, 0) If not @error Then GUISetState(@SW_SHOW) Sleep(5000) _GIF_DeleteGIF($hGIF) EndIf GUIDelete($hWnd_Janela) If @Compiled Then FileDelete($sPastaDestino & $sArquivoGIF) GIFAnimation.au3
  7. Criar e ler um banco de dados SQlite

    Buenas! Sempre que falamos em clonar um banco em memória, nosso objetivo é melhorar o tempo de resposta para funções de massa, como grandes e complexas consultas por exemplo, que talvez ao serem efetuadas a partir do disco (BD original) possam resultar bem mais lentas para apresentar os resultados. Grandes alterações no banco como inserção em massa de dados, alterações ou exclusões também podem ocorrer. Então, ao clonarmos o BD para a memória, temos que ter em mente que eventuais alterações feitas na memória podem ter 2 (dois) destinos: são ignoradas, ou seja o BD serve apenas para SELECTs e o que vale é o BD em disco; precisam ser salvas, ou seja, em algum momento, precisam ser descarregadas/efetivadas/replicadas em disco. Na opção 1, o problema está resolvido. Ignora-se o BD em memória e tudo bem! Na opção 2 o buraco é bem mais embaixo. Aqui temos novamente 2 (duas) possibilidades: efetivamos as alterações à medida que acontecem! Pessoalmente é a que eu utilizo por algumas razões: mantenho o BD em memória igual ao BD no disco (sincronização); caso ocorra alguma falha no equipamento (reset, falta de luz, travamento, etc) as alterações estão seguras; ao iniciar o script, carrego novamente o BD em memória, sabendo que é a última versão das informações e parto disto; não preciso me preocupar em descarregar as alterações posteriormente (no final do programa ou em algum ponto definido) e neste momento qualquer ganho de tempo que eu tive, foi por água abaixo, pois o tempo de gravação em disco de todas as alterações é enorme. Como fazemos isso? Após a clonagem do BD em memória, qualquer alteração ao ser executada, deve ser feita tanto em memória como em disco. #include <Sqlite.au3> ; incializa SQLite _SQLite_Startup() ; Abre BD em mmória Local $hBD_Mem = _SQLite_Open() ; Abre BD em disco Local $hBD_Disco = _SQLite_Open(@ScriptDir & "\BancoDeDados.db") ; ... ; Faz a clonagem conforme as técnicas explicadas em post anterior ; ... ; faz as eventuais alterações no BD mem e no BD disco _SQLite_Exec($hBD_Mem, "UPDATE Tabela SET Estado = "SC" WHERE Codigo = 425;") _SQLite_Exec($hBD_Disco, "UPDATE Tabela SET Estado = "SC" WHERE Codigo = 425;") ; faz as eventuais alterações no BD mem e no BD disco _SQLite_Exec($hBD_Mem, "DELETE FROM Tabela WHERE Idade < 18;") _SQLite_Exec($hBD_Disco, "DELETE FROM Tabela WHERE Idade < 18;") ; fecha tudo _SQLite_Close() _SQLite_Shutdown() Desta forma, mantemos os dois bancos de dados iguais e atualizados. E quaisquer consultas (SELECTs) devem ser feitos diretamente no BD em memória para obter um ganho considerável de velocidade! A outra possibilidade envolve não manter os 2 (dois) bancos equiparados ou sincronizados, mas fazer as alterações somente em memória e depois de tudo pronto, descarregar o BD da memória em disco. Este procedimento pode ser feito a qualquer momento, mas normalmente é efetivado na saída do programa (final do script). Para tanto, infelizmente não há um comando ou comandos que possam fazer isto rapidamente. Felizmente a partir da versão 3.6.x do SQLite, foi implemntadado a API de Backup, que permite fazer cópia do banco "on-the-fly" (com o banco aberto e operando). No fórum americano, tem um tópico sobre isto (cortesia do Belini que achou) e também tem uma função para fazer o backup: Se quiser ver o tópico original = https://www.autoitscript.com/forum/topic/108151-sqlite-backup-api-wrapper/ Vou anexar aqui uma versão modificada da original, já contendo as alterações sugeridas pelos integrantes do fórum naquele tópico e com algumas modificações minhas também. Para utilizar a função de Backup é bem simples. Segue exemplo: #include <Sqlite.au3> #include "sqlitebackup.au3" ; incializa SQLite _SQLite_Startup() ; Abre BD em mmória Local $hBD_Mem = _SQLite_Open() ; Abre BD em disco Local $hBD_Disco = _SQLite_Open(@ScriptDir & "\BancoDeDados.db") ; ... ; Faz a clonagem conforme as técnicas explicadas em post anterior ; ... ; faz as eventuais alterações SOMENTE na memória _SQLite_Exec($hBD_Mem, "UPDATE Tabela SET Estado = "SC" WHERE Codigo = 425;") ; faz as eventuais alterações SOMENTE na memória _SQLite_Exec($hBD_Mem, "DELETE FROM Tabela WHERE Idade < 18;") ; faz o backup do BD em memória de volta para o disco (recomendado ao final do script) _SQLite_Backup($hBD_Mem, @ScriptDir & "\BancoDeDadosCOPIA.db") ; fecha tudo _SQLite_Close() _SQLite_Shutdown() Mas conversando com um outro colega (meu ex-orientandor de mestrado) que é DBA, ele me comentou que alguns engines DBs aproveitam comandos de manutenção do banco (que exigem controle total sobre o mesmo) para efetivar algum tipo de cópia. Assim, fui pesquisar na documentação do SQLite e o comando VACUUM, que serve para fazer uma lmpeza interna do banco, a partir da versão 3.27 possui uma cláusula INTO que faz exatamente isto! Agora temos 2 (duas) opções de salvar o banco de dados da memória em disco. Faca os testes e veja qual a melhor (ou a mais rápida) que serve para o seu caso. A vantagem é que não precisa de uma função externa. #include <Sqlite.au3> ; incializa SQLite _SQLite_Startup() ; Abre BD em mmória Local $hBD_Mem = _SQLite_Open() ; Abre BD em disco Local $hBD_Disco = _SQLite_Open(@ScriptDir & "\BancoDeDados.db") ; ... ; Faz a clonagem conforme as técnicas explicadas em post anterior ; ... ; faz as eventuais alterações SOMENTE na memória _SQLite_Exec($hBD_Mem, "UPDATE Tabela SET Estado = "SC" WHERE Codigo = 425;") ; faz as eventuais alterações SOMENTE na memória _SQLite_Exec($hBD_Mem, "DELETE FROM Tabela WHERE Idade < 18;") ; faz o backup do BD em memória de volta para o disco (recomendado ao final do script) aproveitando o comando interno VACUUM _SQLite_Exec($hBD_Mem, "VACUUM INTO '" & @ScriptDir & "\BancoDeDadosCOPIA.db'") ; fecha tudo _SQLite_Close() _SQLite_Shutdown() Quanto à eficiência de gravação de volta em disco, temos que lembrar que estas funções, tanto a do SQLite como a do backup da SQLite, foram desenvolvidas tendo em mente uqe estes bancos estariam abertos, sendo utilizados por mais de 1 (um) usuário, portanto durante o procedimento de fazer a cópia, é possível que haja alterações por parte de outros usuários, sendo assim, a cópia já nasceria desatualizada. A API do Backup prevê isso e se necessário, recomeça a cópia par refletir estas alterações. Porém naturalmente que dependendo da quantidade de usuários conectados ou das alterações que estão sendo feitas, a cópia pode demorar eternamente! Outro ponto interessante a ser verificado é que o 5o (quinto) parâmetro da função de Backup é o tamanho do bloco que deve ser copiado. E por tamanho do bloco, temos que olhar a estrutura interna do banco de dados para entendermos melhor este parâmetro e o porque da fixação dele em 16. Todo banco de dados, internamente, possui as informações gravadas em blocos como se fossem páginas de um livro. Dentro da página tem as várias informações de vários registros. O procedimento de backup faz cópia de "x" folhas por vez (padrão de 16). Assim caso alguma dessas folhas sejam modificadas, ela recopia somente estas folhas que estão no bloco. Em teoria, quanto menor este bloco melhor, pois estaríamos reduzindo a recópia (se necessário), porém ao reduzirmos o tamanho do bloco, também aumentamos o tempo necessário para copiar tudo. Assim, aumentar o tamanho do bloco faz com que a cópia seja mais rápida, mas mais sujeita a recópias. Dependendo da situação, e eu estou imaginando que em 90% (ou mais) dos casos de SQLIte com AutoIt, os bancos são praticamente exclusivos, não tem niguém além do próprio script mexendo e também não há vários scripts rodando simultameamente na rede. Se for este o seu caso, pode aumentar o nro de blocos para 256 para obter uma melhor performance na cópia do banco ou até mesmo colocar o valor de -1, para que seja usada a velocidade máxima. Mas muito cuidado com estes parâmetros. Eles devem ser cuidadosamente considerados em razão do ambiente em que o banco de dados está sendo executado. _SQLite_Backup($hBD_Mem, $sCopiaBD, Default, Default, 256) ou _SQLite_Backup($hBD_Mem, $sCopiaBD, Default, Default, -1) SQLitebackup.au3
  8. Criar e ler um banco de dados SQlite

    Para clonar o banco de dados em memória, tem várias opções. Todas dá no mesmo, mas vc escolhe a melhor. Opção 1 (a mais rápida): #include <Sqlite.au3> ; inicializa SQLite _SQLite_Startup() Local $hBD_Mem = _SQLite_Open() ; importa os dados _SQLite_Exec($hBD_Mem, "ATTACH DATABASE '" & @ScriptDir & "\BancoDeDados.db' as Original;") _SQLite_Exec($hBD_Mem, "CREATE TABLE Dados AS SELECT * FROM Original.Dados;") _SQLite_Exec($hBD_Mem, "DETACH DATABASE Original;") ; fecha tudo _SQLite_Close($hBD_Mem) _SQLite_Shutdown() Opção 2 (a intermediária), precisa saber a estrutura do banco. É útil quando vc precisa mudar a estrutura ou precisa pegar apenas alguns campos: #include <Sqlite.au3> ; inicializa SQLite _SQLite_Startup() Local $hBD_Mem = _SQLite_Open() ; importa os dados _SQLite_Exec($hBD_Mem, "ATTACH DATABASE '" & @ScriptDir & "\BancoDeDados.db' as Original;") _SQLite_Exec($hBD_Mem, "CREATE TABLE IF NOT EXISTS Dados (Numeros TEXT);") _SQLite_Exec($hBD_Mem, "INSERT INTO Dados SELECT * FROM Original.Dados;") _SQLite_Exec($hBD_Mem, "DETACH DATABASE Original;") ; fecha tudo _SQLite_Close($hBD_Mem) _SQLite_Shutdown() Opção 3 (a mais lenta), mas é a que permite mostrar alguma coisa tipo uma barra de progresso. Útil quando a tabela é muito grande. #include <Sqlite.au3> ; inicializa SQLite _SQLite_Startup() Local $hBD_Mem = _SQLite_Open() Local $hBD_Disco = _SQLite_Open(@ScriptDir & "\BancoDeDados.db") If @error Then ConsoleWrite("Erro na abertura do banco de dados" & @CRLF) Exit EndIf ; seção que carrega a tabela em memória (array) Local $aConsulta, $nLinhas, $nColunas SplashTextOn("", "Inicializando banco de dados...", 600, 100, -1, -1, 1 + 32, "", 24) Local $nResultado = _SQLite_GetTable2d($hBD_Disco, "SELECT * FROM Dados;", $aConsulta, $nLinhas, $nColunas) Sleep(1000) SplashOff() ; importa os dados If $nResultado = $SQLITE_OK Then Local Enum $DB_NUMEROS ProgressOn("Atenção!", "Carregando banco de dados...", "0%") _SQLite_Exec($hBD_Mem, "CREATE TABLE IF NOT EXISTS Dados (Numeros TEXT);") For $nIndice = 1 to $nLinhas ProgressSet($nIndice / $nLinhas * 100, Round($nIndice / $nLinhas * 100, 2) & '%') _SQLite_Exec($hBD_Mem, 'INSERT INTO Dados (Numeros) VALUES ("' & $aConsulta[$nIndice][$DB_NUMEROS] & '");') Next ProgressSet(100, '100%') Sleep(250) ProgressOff() EndIf ; fecha tudo _SQLite_Close($hBD_Mem) _SQLite_Close($hBD_Disco) _SQLite_Shutdown()
  9. Criar e ler um banco de dados SQlite

    Entendi a questão da memória, mas daí não tem jeito de fazer isso diretamente. Vc trá que criar um "clone" do banco em memória e importar o conteúdo do BD em disco e a partir daí trabalhar só com o da memória. E se necessário, fazer as alterações em disco a medida que acontecem. Eu tenho um script assim. Ao iniciar, carrego todo o banco em memória, daí todas as consultas são no BD em memória e faço as gravações (eventuais) em disco simultaneamente. E os cartões? Como são divididos?
  10. Criar e ler um banco de dados SQlite

    Outra coisa. Quem fez o post americano tbm não entendia muito de BD ou estava começando. Em teoria, os passos são: vc abre o BD cria as tabelas internas e os relacionamentos inclue, altera, exclue ou consulta dos dados Os passos 1 e 2 ocorrem apenas uma vez, já o 3o passo ocorre gradativamente. Por isto que eu me arrepio quando vejo o código postado. If Not FileExists("database.db") Then $dbn = _SQLite_Open("database.db") _SQLite_Exec($dbn, "CREATE TABLE Dados (Numeros);") For $i = 1 To 10 $dados = "PM-S" & $i & "=02 05 06 08 15 20 23 26 28 30 35 36 38 43 45 47 52 54 55 56 66 68 71 74 75 PM-Q" & $i & " 10" $sql = "INSERT INTO Dados VALUES('" & $dados & "');" ;_Base_Execute($sql) _SQLite_Exec($dbn, $sql) Next Else $dbn = _SQLite_Open("database.db") EndIf Para começo de conversa, qual a diferença entre as linhas de abertura do BD com o _SQLite_Open? Se não existe o arquivo físico, abre o banco! E se existe, abre o banco? Não se deve confundir a abertura e criação do BD com sua manutenção. Eu faria assim: ; seção de abertura do BD $dbn = _SQLite_Open("database.db") _SQLite_Exec($dbn, "CREATE TABLE IF NOT EXIST Dados (Numeros TEXT);") ; seção de inclusão de dados For $i = 1 To 10 $dados = "PM-S" & $i & "=02 05 06 08 15 20 23 26 28 30 35 36 38 43 45 47 52 54 55 56 66 68 71 74 75 PM-Q" & $i & " 10" $sql = "INSERT INTO Dados VALUES('" & $dados & "');" _SQLite_Exec($dbn, $sql) Next Observe: a clásula IF NOT EXIST no comando CREATE TABLE (assim cria somente se a tabela não existir, evitando que a tabela seja zerada toda vez) o tipo TEXT para definição do campo Numeros. Apesar de opcional, é sempre importante colocar. Neste caso, o BD seria aberto, criado se necessário o arquivo físico e a(s) tabela(s) internas. Em um segundo momento, os dados seriam incluídos. Claro que olhando para o script, os dados seriam inclusos sempre, por isso que a inclusão só poderia acontecer em um script separado para alimentar o BD inicialmente (recomendado) ou uma condição que permitisse a inserção dos dados na tabela apenas uma única vez. ; seção de abertura do BD $dbn = _SQLite_Open("database.db") _SQLite_Exec($dbn, "CREATE TABLE IF NOT EXIST Dados (Numeros TEXT);") Local $aRegistro ; verifica se tem alguma coisa no BD _SQLite_QuerySingleRow($dbn, "SELECT COUNT(Numeros) FROM Dados;", $aRegistro) If $SQLITE_OK and not $aRegistro[0] Then ; se não existir NENHUM cartão, insere os dados ; seção de inclusão de dados For $i = 1 To 10 $dados = "PM-S" & $i & "=02 05 06 08 15 20 23 26 28 30 35 36 38 43 45 47 52 54 55 56 66 68 71 74 75 PM-Q" & $i & " 10" $sql = "INSERT INTO Dados VALUES('" & $dados & "');" _SQLite_Exec($dbn, $sql) Next EndIf Ok, agora temos um procedimento adequado para criar e inserir os dados (se necessário). Para criar um BD em memória basta mudar a linha $dbn = _SQLite_Open("database.db") para $dbn = _SQLite_Open() Porém, daí todos os dados colocados no BD desaparecerão quando e se o programa fechar ou a máquina desligar/reiniciar, etc Em compensação, as operações são super rápidas. Mas eu acho que a sua cartela pode ser desdobrada em campos menores. Seguindo o post anterior, me explique tbm o que são os nros? PM-S 1,2,3, etc - o que é? = 02 05 06 08 etc - imagino que são os nros sorteados na cartela PM-Q 1,2,3, etc - o que é? Pensei numa ideia maluca aqui, vamos ver se vinga ;)
  11. Criar e ler um banco de dados SQlite

    Queria entender um pouco mais sobre esta questão de "gerar os cartões" que totalizariam 2 milhões de linhas. Estes cartões já estão gerados? Estão em um arquivo INI, isso? E vc quer importar para um BD? Se for assim, o procedimento de leitura do INI e gravação no BD vc já tem. Será demorado? Provavelmente, mas como vc mesmo disse, é uma operação que pode ser feita "off-line", ou seja, o cliente nunca vai saber que aconteceu. Vc já vai chegar com o BD pronto para ele. Mas a minha pergunta é exatamente essa! É necessário gravar todos estes cartões antecipadamente? Como funciona um bingo na prática? Faça de conta que vc não tem nenhum cartão gerado. Primeira vez que vc entrou num bingo. São gerados quantos cartões? Ficam gravados porque? PS. Quanto à dúvida técnica do BD em memória, basta não utilizar nenhum parâmetro no comando _SQLite_Open, daí o BD é gerado em memória.
  12. Criar e ler um banco de dados SQlite

    Oi Belini. Foi o que pensei. Acredito que vc esteja tentando usar o BD como substituto mais rápido dos arquivos INI, mas há a possibilidade de um melhoramento considerável aqui. Tu já considerastes que basta apenas um campo a mais no 1a arquivo INI, marcando a cartela como já vendida? Daí não precisaria "apagar: do 1a INI e gravar no 2o. E a pesquisa, devido ao modelo TXT não ter nenhum tipo de pesquisa (afinal é apenas um monte de informação), é necessário fazer manualmente, como vc fez, através de For..Next, mas no BD vc manda ele pesquisar e pergunta se achou, simples assim! E a questão da estatística, também um campo incrementado pode fazer isso. Mas eu acho que ainda é possível que haja uma possibilidade de pesquisa das cartelas de modo diferente. Vou pensar a respeito. Entendeu a idéia?
  13. Criar e ler um banco de dados SQlite

    A quantidade de linhas não faz diferença. Ter 1 linha ou 1 milhão de linhas não muda nada para o gerenciamento do banco. Ter 3 tabelas dentro do banco ou 1 tabela apenas, depende de vc. Na verdade, acredito que manter tudo em uma mesma tabela será melhor, pois a manutenção e a consulta dos dados será unificada. Mas você pode explicar melhor o que vc está fazendo? Talvez o teu foco no banco pode estar errado, se vc estiver olhando ele como uma extensão dos arquivos INI.
  14. Criar e ler um banco de dados SQlite

    Olá. O erro está na sintaxe do comando de INSERT, pois o AutoIt converte para string a tua variável $dados, mas a forma final está errada. Só mude a linha $sql = "INSERT INTO matematica(numeros)VALUES(" & $dados & ");" para $sql = "INSERT INTO matematica(numeros) VALUES('" & $dados & "');" Quanto à quantidade de banco de dados, vc pode ter apenas 1 arquivo físico e dentro dele vc pode ter quantas tabelas quiser. Basta dar um CREATE TABLE para cada arquivo que vc quer dentro do banco.
  15. SQLite Básico

    Olá a todos. Para utilização do SQLite, dentro de uma aplicação desenvolvida em AutoIT, é muito simples. Tudo que precisamos fazer é: informar ao AutoIt que gerenciador utilizar (carregar a DLL do AutoIt) acessar o banco desejado fazer as operações necessárias fechar o banco e desativar a DLL Infelizmente ao trabalhar com banco de dados a sintaxe SQL é obrigatória. Se vc não conhece os comandos básicos de SQL então não será possível trabalhar no SQLite. Nosso objetivo aqui é mostrar como utilizar o SQLite em conjunto com o AutoIt, portanto parte-se da premissa que pelo menos os comandos básicos de SQL já são conhecidos. Os comandos básicos incluem criação da estrutura das tabelas, manutenção dos dados (inclusão, alteração e exclusão) e recuperação das informações. Essa sintaxe SQL ou os comandos podem ser estudados na página do SQLite (http://sqlite.org/lang.html) ou quaisquer outras fontes na internet. Minha recomendação é aprender pelo menos, os seguintes comandos: Em relação à estrutura das tabelas (ou arquivos): CREATE TABLE - criação de tabelas ALTER TABLE - alteração da estrutura da tabela DROP TABLE - exclusão de tabelas Em relação às informações dentro das tabelas: INSERT - insere informações UPDATE - atualiza as informações DELETE - deleta informações Em relação a como recuperar as informações SELECT - solicita os dados A grande vantagem em aprender o básico de SQL é que todos os bancos de dados atuais no mercado seguem esta sintaxe, ou seja, independente de utilizar o SQLite ou Oracle, a sintaxe é basicamente a mesma, com pequenas variações próprias de cada banco. Portanto ao aprender SQL, estamos aprendendo a trabalhar com qualquer banco. Agora, vamos de volta ao SQLite com AutoIt. Passo 1: informar ao AutoIt para usar o padrão SQLite pelo comando _SQLite_Startup. Do manual: #include <SQLite.au3> _SQLite_Startup ( [$sDll_Filename = "" [, $bUTF8ErrorMsg = False [, $iForceLocal = 0 [, $hPrintCallback = $__g_hPrintCallback_SQLite]]]] ) Temos alguns parâmetros adicionais ao comando que DEVEM ser observados: $sDll_Filename -> se não informada será usada o padrão sqlite3.dll ou sqlite3_x64.dll em sistemas de 64 bits. Se informada, o nome da DLL será procurado literalmente. $iForceLocal -> se deve procurar a DLL especificada em outras pastas padrão do sistema como @ScriptDir, @SystemDir, @WindowsDir and @WorkingDir Portanto se vc usar apenas o comando _SQLite_Startup() está dizendo ao AutoIt para abrir a DLL chamada SQLITE3.DLL que está obrigatoriamente na pasta do programa OU na pasta WINDOWS OU na pasta WINDOWS\SYSTEM32. Observe que se estiver em um ambiente de 64 bits, o arquivo a ser procurado automaticamente será o SQLITE3_X64.DLL. Se quiser especificar uma DLL, informe o nome e caminho completo da mesma _SQLite_Startup("C:\Pasta\NomeDoArquivo.DLL") ou _SQLite_Startup(@ScriptDir & "\NomeDoArquivo.DLL")Atenção que o sufixo "_x64" é adicionado SEMPRE (independente do nome ser informado ou não) em caso de ambiente de 64 bits. O retorno do comando identifica se realmente conseguiu carregar a DLL ou não. Se conseguiu carregar, retorna o nome da DLL carregada Se não conseguiu, seta @error e retorna uma string em branco ("") Para obter as DLLs necessárias para poder trabalhar com AutoIt tem duas maneiras: pegar do repositório oficial do AutoIt em https://www.autoitscript.com/autoit3/pkgmgr/sqlite/ pegar direto do fabricante SQLite em http://sqlite.org/download.html Até a versão 3.3.14.1 do AutoIt, existia uma cópia da DLL em código de máquina dentro da pasta Include, bastando para ter acesso à SQLite que se fizesse uso do seguinte comando: #include <SQLite.dll.au3>Porém na versão 3.3.14.2 (última) este arquivo foi substituído por uma simples checagem de versão, cabendo ao programador procurar e baixar manualmente a DLL. #FikaDika: Baixem também o SQLITE3.EXE, assim é possível "entrar" num ambiente do SQLite para testar os comandos e assim por diante. Ótimo para verificar se a sintaxe do comando SQL está correta, senão pode dar erro e não se sabe se é no SQLite ou no AutoIt. Passo 2: acessar o banco desejado. Para isso utiliza-se o comando _SQLite_Open Para abrir/criar um banco em disco: _SQLite_Open("Nome e caminho completo do arquivo de banco de dados")O retorno no comando é o handler (ou código) do banco aberto. Se der erro, seta @error e o handler é zero! A partir do momento que o banco está aberto, já estão disponíveis as operações #FIkaDika: Notem que o SQLite tem uma característica muito interessante que é a criação e o uso de tabelas EM MEMÓRIA, ou seja, toda a estrutura é criada e mantida apenas na memória RAM (claro que foge ao princípio do armazenamento permanente), mas permite ao programador utilizar todo o poder do SQLite de forma extremamente veloz. Eu pessoalmente utilizo como alternativa melhorada dos arrays. Para abrir/criar um banco em memória: _SQLite_Open(":memory:")ou simplesmente _SQLite_Open() Passo 3: fazer as operações desejadas As operações são basicamente comandos a serem enviados ao SQLite informando o que desejamos fazer. Neste ponto há a necessidade de conhecimento de linguagem SQL, pelo menos básico (já comentado). Existem basicamente dois tipo de comandos: os comandos de consulta os demais comandos Os comandos de consulta servem para recuperar as informações do banco de dados. Tem algumas variantes mas o principal é _SQLite_Query. Ao utilizar o _SQLite_Query o retorno acontece em um conjunto de dados que deve ser posteriormente lido e processado de acordo. Sua sintaxe é: _SQLite_Query($hDB, $sSQL, ByRef $hQuery)onde $hDB é o handler do banco obtido através do _SQLite_Open $sSQL é o comando SELECT necessário para solicitar os dados que precisamos $hQuery é a variável que é passada por referência que vai conter o conjunto de dadso recuperados Como dito antes, é necessário processar o conjunto de dados que foi gerado através da consulta. Para isso utilizamos o _SQLite_FetchData em um loop. Local $Consulta, $Campo _SQLite_Query($Handle_DB, "SELECT Nome,Telefone FROM Clientes ORDER BY Nome", $Consulta) While _SQLite_FetchData($Consulta, $Campo) = $SQLITE_OK    ConsoleWrite($Campo[0] & " - " & $Campo[1]) WEnd Para esclarecer, os campos que são consultados no comando _SQLite_FetchData retornam em um array base 0 onde cada campo segue a sequência. Exemplos: SELECT Nome,Telefone FROM Clientes $Campo[0] é o Nome $Campo[1] é o Telefone SELECT Nome,Endereco,Telefone FROM Clientes $Campo[0] é o Nome $Campo[1] é o Endereco $Campo[2] é o Telefone SELECT Telefone,Nome FROM Clientes $Campo[0] é o Endereco $Campo[1] é o Nome Os demais comandos são na verdade, comandos em sintaxe SQL que são enviados ao SQLite através do comando _SQLite_Exec. Se observarmos atentamente, veremos que o comando _SQLite_Query também é um comando SQL, porém a diferença é que neste caso, há um conjunto de informações a serem recuperados, ao passo que o _SQLite_Exec, por exemplo, retorna apenas se o comando foi ou não executado. _SQLite_Exec($hDB, $sSQL [, $sCallBack = ""])onde $hDB é o handler do banco obtido através do _SQLite_Open $sSQL é o comando SQL que queremos que seja executado Se deu certo o comando retorna 0 (ou melhor a constante $SQLITE_OK) Se não deu, retorna um código de erro. Este código pode ser comparado com as constantes do SQLite ou pode-se utilizar o comando _SQLite_ErrMsg para obter uma mensagem mais extensa (em inglês). Exemplos: Para criar uma tabela CLIENTES no banco de dados com 4 campos (codigo, nome, endereco e telefone) _SQLite_Exec($Handle_DB, "CREATE TABLE Clientes (Codigo INTEGER, Nome TEXT, Endereco TEXT, Telefone TEXT);")Para criar uma tabela CARROS com 2 campos (placa e chassi) _SQLite_Exec($Handle_DB, "CREATE TABLE Carros (Placa TEXT, Chassi TEXT);") Para incluir um carro na tabela CARROS _SQLite_Exec($Handle_DB, "INSERT INTO Carros VALUES ('ABC1234','9BWHE21JX24060960');" Para alterar um cliente na tabela CLIENTES (previamente criada) _SQLite_Exec($Handle_DB, "UPDATE Clientes SET Endereco = 'RUA DOS ANZOIS, S/N' WHERE Codigo = 6");" FikaDika: Atentar para o detalhe que TODOS os comandos que são passados para o SQL através do comando _SQLite_Exec PRECISAM ser terminados com ; (ponto e vírgula). Outro detalhe interessante sobre banco de dados é que 1 (UM) banco pode conter VÁRIAS tabelas internas, relacionadas ou não entre si. Cada tabela armazena um tipo de informação e são trabalhadas independente uma das outras. FikaDika2: Ao criar as tabelas, pode-se utilizar a opção IF NOT EXISTS, dessa forma, a tabela será criada apenas uma vez, senão corremos o risco de APAGAR a tabela recriando-a ou simplesmente dar ERRO no comando porque a tabela ja existe! CREATE TABLE IF NOT EXISTS Carros (Placa TEXT, Chassi TEXT) Passo 4: fechar o banco de dados e desativar a DLL Finalmente para fechar o banco e desativar a DLL os comandos são: _SQLite_Close([$hDB = -1]) onde $hDB é o handler do banco obtido através do _SQLite_Open e _SQLite_Shutdown()que descarrega a DLL da memória (ou desativa) Exemplo final prático: #include <Sqlite.au3> $SQLite_DLL = _SQLite_Startup() ConsoleWrite("Utilizando " & StringUpper($SQLite_DLL) & " v" & _SQLite_LibVersion() & @CRLF) Local $Handle_DB = _SQLite_Open() _SQLite_Exec($Handle_DB, "CREATE TABLE Clientes (Codigo NUMERIC, Nome TEXT, Endereco TEXT, Telefone TEXT);") _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (1, 'Fulano de Tal', 'Rua das Flores, 123', '(00) 1234-5678');") _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (2, 'Beltrano de Qual', 'Outra Rua Qualquer, s/n', '(00) 5678-1234');") MOSTRA_CLIENTES() _SQLite_Exec($Handle_DB, "UPDATE Clientes SET Endereco = 'RUA DOS ANZOIS, 100' WHERE Codigo = 2;") MOSTRA_CLIENTES() _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (3, 'Mais um Maluco', 'Hospicio Geral, sl 2', '(00) 8274-5382');") MOSTRA_CLIENTES() _SQLite_Exec($Handle_DB, "DELETE FROM Clientes WHERE Codigo = 1;") MOSTRA_CLIENTES() _SQLite_Exec($Handle_DB, "DROP TABLE Clientes;") _SQLite_Close($Handle_DB) _SQLite_Shutdown() Exit Func MOSTRA_CLIENTES() Local $Consulta, $Informacao ConsoleWrite(@CRLF & "Lista de Clientes" & @CRLF) _SQLite_Query($Handle_DB, "SELECT Nome,Endereco,Telefone FROM Clientes ORDER BY Nome;", $Consulta) While _SQLite_FetchData($Consulta, $Informacao) == $SQLITE_OK ConsoleWrite("Nome: " & $Informacao[0] & " - Endereço: " & $Informacao[1] & " - Telefone: " & $Informacao[2] & @CRLF) WEnd EndFunc Mesmo exemplo porém com tratamento de erros: #include <Sqlite.au3> Local $SQLite_DLL = _SQLite_Startup() If $SQLite_DLL = "" Then ConsoleWrite("Erro ao carregar SQLITE.DLL" & @CRLF) Exit EndIf ConsoleWrite("Utilizando " & StringUpper($SQLite_DLL) & " v" & _SQLite_LibVersion() & @CRLF) Local $Handle_DB = _SQLite_Open() If $Handle_DB = 0 Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao abrir banco de dados" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf If _SQLite_Exec($Handle_DB, "CREATE TABLE Clientes (Codigo NUMERIC, Nome TEXT, Endereco TEXT, Telefone TEXT);") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao abrir criar tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf If _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (1, 'Fulano de Tal', 'Rua das Flores, 123', '(00) 1234-5678');") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao inserir na tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf If _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (2, 'Beltrano de Qual', 'Outra Rua Qualquer, s/n', '(00) 5678-1234');") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao inserir na tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf MOSTRA_CLIENTES() If _SQLite_Exec($Handle_DB, "UPDATE Clientes SET Endereco = 'RUA DOS ANZOIS, 100' WHERE Codigo = 2;") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao atualizar tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf MOSTRA_CLIENTES() If _SQLite_Exec($Handle_DB, "INSERT INTO Clientes VALUES (3, 'Mais um Maluco', 'Hospicio Geral, sl 2', '(00) 8274-5382');") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao inserir na tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf MOSTRA_CLIENTES() If _SQLite_Exec($Handle_DB, "DELETE FROM Clientes WHERE Codigo = 1;") <> $SQLITE_OK Then ConsoleWrite("Erro " & _SQLite_ErrCode() & " ao excluir da tabela CLIENTES" & @CRLF) ; verifique os erros dentro da Sqlite.au3 Exit EndIf MOSTRA_CLIENTES() _SQLite_Exec($Handle_DB, "DROP TABLE Clientes;") _SQLite_Close($Handle_DB) _SQLite_Shutdown() Exit Func MOSTRA_CLIENTES() Local $Consulta, $Informacao ConsoleWrite(@CRLF & "Lista de Clientes" & @CRLF) _SQLite_Query($Handle_DB, "SELECT Nome,Endereco,Telefone FROM Clientes ORDER BY Nome;", $Consulta) While _SQLite_FetchData($Consulta, $Informacao) == $SQLITE_OK ConsoleWrite("Nome: " & $Informacao[0] & " - Endereço: " & $Informacao[1] & " - Telefone: " & $Informacao[2] & @CRLF) WEnd EndFunc O resultado dos exemplos acima deve ser: Utilizando SQLITE3_X64.DLL v3.8.11.1 Lista de Clientes Nome: Beltrano de Qual - Endereço: Outra Rua Qualquer, s/n - Telefone: (00) 5678-1234 Nome: Fulano de Tal - Endereço: Rua das Flores, 123 - Telefone: (00) 1234-5678 Lista de Clientes Nome: Beltrano de Qual - Endereço: RUA DOS ANZOIS, 100 - Telefone: (00) 5678-1234 Nome: Fulano de Tal - Endereço: Rua das Flores, 123 - Telefone: (00) 1234-5678 Lista de Clientes Nome: Beltrano de Qual - Endereço: RUA DOS ANZOIS, 100 - Telefone: (00) 5678-1234 Nome: Fulano de Tal - Endereço: Rua das Flores, 123 - Telefone: (00) 1234-5678 Nome: Mais um Maluco - Endereço: Hospicio Geral, sl 2 - Telefone: (00) 8274-5382 Lista de Clientes Nome: Beltrano de Qual - Endereço: RUA DOS ANZOIS, 100 - Telefone: (00) 5678-1234 Nome: Mais um Maluco - Endereço: Hospicio Geral, sl 2 - Telefone: (00) 8274-5382
  16. Criar e ler um banco de dados SQlite

    Depois, para fins de pesquisa, vc vai usar o comando _SQLite_Query para pesquisar o que vc quer, independente de qual linha está. Em teoria, vc usa o IniRead para puxar o que vc precisa e depois compara com o resultado dentro do banco. Tenha em mente que o SQLite (ou qualquer outro banco), ao fazer uma pesquisa ele sempre "cria" um subconjunto de dados que fecham com as condições estabelecidas pelo comando QUERY. Então vc sempre vai precisar "varrer" este subconjunto para pegar a informação que vc precisa. #include <Sqlite.au3> ; inicializa o SQLite. Não esquecer das DLL com os nomes certos e na pasta do script $SQLite_DLL = _SQLite_Startup() If @error Then ConsoleWrite("Erro de inicialização da SQLite" & @CRLF) Exit EndIf ; aqui está abrindo um banco em memória, ou seja, não fica nada gravado em disco Local $Handle_DB = _SQLite_Open() If @error Then ConsoleWrite("Erro na abertura do banco de dados" & @CRLF) Exit EndIf ; cria a tabela NUMEROS com apenas um campo chamado LINHA que contém texto genérico _SQLite_Exec($Handle_DB, "CREATE TABLE Numeros (Linha TEXT);") ; insere os dados na tabela _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('1=01 03 05 11 15 17 19 25 26 28 33 36 40 42 45 47 48 54 57 60 64 66 67 70 75 PG-Q01 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('2=03 05 07 08 15 20 23 26 28 30 35 36 38 43 45 47 52 54 55 56 66 68 71 74 75 PG-Q02 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('3=02 07 10 12 14 16 17 23 26 28 32 34 35 39 41 48 49 52 54 58 61 62 63 70 72 PG-Q03 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('4=05 06 11 14 15 16 17 24 25 30 33 36 42 43 44 46 49 50 51 60 63 64 66 74 75 PG-Q04 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('5=02 01 05 08 17 19 23 24 27 28 31 39 40 44 45 47 49 51 55 59 61 63 66 74 75 PG-Q05 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('6=01 03 10 14 15 18 19 23 24 28 31 35 36 39 40 47 48 54 56 59 61 62 63 64 65 PG-Q06 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('7=02 07 09 15 18 20 21 23 25 30 31 36 41 42 43 46 50 51 56 59 63 64 70 74 75 PG-Q07 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('8=04 06 08 11 12 19 21 24 27 29 33 34 39 44 45 46 48 51 55 57 65 67 72 73 74 PG-Q08 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('9=04 05 08 14 15 17 20 25 28 30 36 39 41 42 44 46 51 55 57 60 63 64 72 74 75 PG-Q09 10');") ; lê o que vc precisa no arquivo INI Local $sTexto = IniRead(@ScriptDir & "\Arquivo.Ini", "Numeros", "Chave", "") If not $sTexto Then ConsoleWrite("Erro na leitura do arquivo INI" & @CRLF) Exit EndIf ; faz a pesquisa no banco Local Enum $DB_LINHA Local $Consulta, $Informacao _SQLite_Query($Handle_DB, "SELECT Linha FROM Numeros WHERE Linha = '" & $sTexto & "';", $Consulta) While _SQLite_FetchData($Consulta, $Informacao) == $SQLITE_OK If $Informacao[$DB_LINHA] = $sTexto Then ConsoleWrite("Achei" & @CRLF) WEnd ; fecha tudo _SQLite_Close($Handle_DB) _SQLite_Shutdown() Se vc precisa apenas verificar se a informação está dentro do banco há outro comando que pode facilitar. O objetivo dele, se funcionar, é trazer um subconjunto de APENAS 1 registro! #include <Sqlite.au3> ; inicializa o SQLite. Não esquecer das DLL com os nomes certos e na pasta do script $SQLite_DLL = _SQLite_Startup() If @error Then ConsoleWrite("Erro de inicialização da SQLite" & @CRLF) Exit EndIf ; aqui está abrindo um banco em memória, ou seja, não fica nada gravado em disco Local $Handle_DB = _SQLite_Open() If @error Then ConsoleWrite("Erro na abertura do banco de dados" & @CRLF) Exit EndIf ; cria a tabela NUMEROS com apenas um campo chamado LINHA que contém texto genérico _SQLite_Exec($Handle_DB, "CREATE TABLE Numeros (Linha TEXT);") ; insere os dados na tabela _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('1=01 03 05 11 15 17 19 25 26 28 33 36 40 42 45 47 48 54 57 60 64 66 67 70 75 PG-Q01 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('2=03 05 07 08 15 20 23 26 28 30 35 36 38 43 45 47 52 54 55 56 66 68 71 74 75 PG-Q02 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('3=02 07 10 12 14 16 17 23 26 28 32 34 35 39 41 48 49 52 54 58 61 62 63 70 72 PG-Q03 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('4=05 06 11 14 15 16 17 24 25 30 33 36 42 43 44 46 49 50 51 60 63 64 66 74 75 PG-Q04 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('5=02 01 05 08 17 19 23 24 27 28 31 39 40 44 45 47 49 51 55 59 61 63 66 74 75 PG-Q05 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('6=01 03 10 14 15 18 19 23 24 28 31 35 36 39 40 47 48 54 56 59 61 62 63 64 65 PG-Q06 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('7=02 07 09 15 18 20 21 23 25 30 31 36 41 42 43 46 50 51 56 59 63 64 70 74 75 PG-Q07 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('8=04 06 08 11 12 19 21 24 27 29 33 34 39 44 45 46 48 51 55 57 65 67 72 73 74 PG-Q08 10');") _SQLite_Exec($Handle_DB, "INSERT INTO Numeros VALUES ('9=04 05 08 14 15 17 20 25 28 30 36 39 41 42 44 46 51 55 57 60 63 64 72 74 75 PG-Q09 10');") ; lê o que vc precisa no arquivo INI Local $sTexto = IniRead(@ScriptDir & "\Arquivo.Ini", "Numeros", "Chave", "") If not $sTexto Then ConsoleWrite("Erro na leitura do arquivo INI" & @CRLF) Exit EndIf ; faz a pesquisa no banco If _SQLite_QuerySingleRow($Handle_DB, "SELECT Linha FROM Numeros WHERE Linha = '" & $sTexto & "';", $Consulta) = $SQLITE_OK Then ConsoleWrite("Achei" & @CRLF) EndIf ; fecha tudo _SQLite_Close($Handle_DB) _SQLite_Shutdown() Veja se isso resolve!
  17. Criar e ler um banco de dados SQlite

    Como dizia o famoso assassino Jack Estripador (ou seu homônimo brasileiro Chico Picadinho), vamos por partes! Quanto ao problema aqui, as linhas são gravadas como se fossem uma linha inteira ou como números isolados? Isso tudo é uma linha só? Ou são vários campo separados (um para cada nro)? E se for uma linha só, vc vai ter 2 milhões de linhas, isso? PS.: Veja minha resposta lá nos exemplos para resolver o problema da abertura do banco de dados.
  18. SQLite Básico

    @Belini Não entendi a questão de não conseguir abrir o banco de dados. Como assim? Preste atenção que um arquivo de banco de dados no SQLite (ou outro bando de dados) não é como um arquivo convencional! A melhor analogia que podemos utilizar é que o "arquivo físico do banco de dados" é como se fosse um arquivo tipo ZIP, por exemplo. Como arquivo ele é inútil, mas dentro dele é que tem os arquivos que precisamos. Da mesma forma funciona um arquivo de banco de dados. Ao criarmos um arquivo "físico" não podemos simplesmente sair utilizando o mesmo, como se fosse um arquivo TXT. É necessário criar as TABELAS dentro do arquivo. Daí finalmente, pode-se incluir, alterar, deletar ou consultar os dados. A maioria das pessoas (eu inclusive) quando comecei com banco de dados, não sabia disso. Tinha uma noção, mas só na prática que fui entender corretamente o SQLite. Hoje não abro mais mão de trabalhar com ele. Finalmente, pela mensagem de erro que vc postou antes: Eu diria que com 99% de certeza que vc está utilizando a DLL errada para o ambiente que vc está trabalhando. O comando de inicialização do SQLite - comando _SQLite_Startup() - é um saco de trabalhar porque ele é pouco intuitivo. Quando dá erro, todas as operações subsequentes não funcionam. No seu caso, a primeira coisa a identificar é o ambiente! É 32 ou 64 bits? E se vc está forçando seu script a trabalhar em qual ambiente? Segunda coisa: os parâmetros do _SQLite_Startup(). Tem duas situações: 1) se não passar nenhum nome como parâmetro ele assume obrigatoriamente os nomes SQLITE3.DLL para ambiente 32 bits e SQLITE3_X64.DLL para ambiente 64 bits quaisquer outros nomes NÃO FUNCIONAM! Dá erro e não inicializa o SqLite! Que acaba dando a msg que vc postou! Outra coisa muito importante, estes arquivos DEVEM estar preferencialmente na mesma pasta do script. A sequência de procura das DLLs é @ScriptDir, @SystemDir, @WindowsDir e @WorkingDir. Quando não acha na pasta do script, vai na pasta @systemdir, depois @windowsdir e finalmente na @workingdir. E novamente os nomes são obrigatoriamente os descritos acima! 2) se passar o nome da DLL a ser aberta e o ambiente for 64 bits, o próprio AutoIt vai acrescentar o sufixo _X64 em qualquer nome que for passado! Isto é um pseudo-bug do AutoIt! Exemplo: _SQLite_Startup("F:\MeuArquivo.Dll") Neste caso, se o ambiente for 32 bits e o arquivo "MeuArquivo.Dll" existir no drive F: a SQLite será inicializada. MAS se for ambiente 64 bits, o sufixo _X64 será incluído automaticamente (pseudo-bug do AutoIt) e o arquivo a ser procurado será o MeuArquivo_X64.Dll, ocasionando um erro porque o arquivo especificado como argumento não existe (ou não foi encontrado). Acredito que este seja o motivo do erro no seu caso. Apesar disto tudo estar escrito no 1o post, acho que não ficou bem claro! Falha minha. Peço desculpas por isso! E por último, quando falamos em forçar o ambiente (32 ou 64 bits) é muito importante que isto esteja bem claro desde o começo em nossos scripts, pois gera uma fonte interminável de dores de cabeça. Independente do ambiente que vc trabalha (não confundir com o ambiente onde vai executar o script depois de pronto), é muito esclarecedor para o script (e para nós mesmos) que tenhamos certeza de onde estamos pisando! Eu pessoalmente utilizo a diretriz #AutoIt3Wrapper_UseX64=n Para informar ao AutoIt qual é o meu ambiente de desenvolvimento. Sempre em 32 bits! Assim, eu garanto que, se eu compilar para teste ou compilar final meu script sempre vai rodar em 32 bits em qualquer ambiente (32 ou 64), e por tabela as DLL associadas também devem ser em 32 bits. Isto interfere um monte no ambiente que está sendo executado, como na macro @ProgramFiles, que pode ser C:\Program Files ou C:\Program Files (x86) ou DLLs a serem carregadas,. Até mesmo a pasta do sistema @SystemDir é afetada, pois pode ser tanto C:\Windows\System32 ou C:\Windows\SysWOW64 Então se o seu script vai rodar em 32 ou 64 bits, tenha certeza que fazer as modificações adequadas no código para evitar confusão depois! Utilize a macro @AutoItX64 par garantir isso. Depois que eu percebi este detalhe e passei a controlar o ambiente, e não deixar por conta, tive trocentos problemas a menos com DLLs e arquivos. Por exemplo, ao procurar por atualização de um arquivo no servidor, sendo que o seu script diferencia o ambiente: Local $sArquivo = "MeuArquivo.Dll" If @AutoItX64 Then $sArquivo = "MeuArquivo64.Dll" If not BAIXAR_ARQUIVO($sArquivo) Then ConsoleWrite('Erro" & @CRLF) Boa sorte!
  19. Ok, então provavelmente está ocorrendo o seguinte: Vc deve estar usando uma versão da DLL diferente da relacionada na documentação! Tipo, as DLLs tbm tem atualização e correção, e são atualizadas junto com as atualizações do Windows. Provavelmente vc deve estar usando uma mais desatualizada (WinXP) e a documentação foi evoluindo até a versão final, que foi no Win7 (se não me engano). Minha recomendação é tentar encontrar outra versão mais atualizada desta mesma DLL, talvez até em Windows mais novos, mas sempre de 32 bits. Quando funcionar o comando acima (movie text show) deve fucionar tbm o comando de stretch! Veja a versão que vc tem (em propriedades, detalhes), veja se consegue encontrar outra, talvez no SP3 ou Win7 e finalmente veja se funciona!
  20. Fui procurar a sintaxe do comando Window e a opção de stretch aparece lá. Faz assim, testa este outro comando, para ver se a função reconhece _mciSendString('window movie text "JukeBel" state show')
  21. Incorporar libmpv no programa

    Show de bola. Parabéns!
  22. Incorporar libmpv no programa

    E Músicas estão incomodando? Ou só os vídeos?
  23. Incorporar libmpv no programa

    Mas não converte tudo, nem precisa. Converta os que incomodam. Aqueles que os clientes reclamam ou aqueles que vc "pescou" numa passada de teste. Realmene não há como trabalhar uma biblioteca deste tamanho!
  24. Incorporar libmpv no programa

    Isso mesmo Mutleey. Foi este o ponto quando comentei que o Belini tem controle sobre o que executa no programa dele. Como o acervo dele (e dos demais) são digamos, entregues pelo desenvolvedor, ao instalar o programa, vc instala tbm o acervo digital. Assim, quaisquer arquivos (vídeo ou áudio) que não toquem, basta transcodificar para um formato "tocável" e substituir o original que não funciona. E isso pode ser feito "offline", no sentido de fazê-lo no momento da escolha e seleçào do acervo a ser dispnibilizado. Já no meu caso, que depende de arquivos do cliente, daí tenho que recorrer ao plaer universal, por enquanto, o MPV.
  25. Incorporar libmpv no programa

    Exatamente por isso que, por enquanto, eu escolhi o MPV como player de fundo. Em determinados casos, as mídias abrem no MCI e não abrem no DS, ou vice-versa. Em outros, tem que atualizar os codecs, outros não. Testei a WMP e até o MPC. Em um teste em outro computador aqui no escritório, o MCI parou de funcionar "do nada". Atualizei codecs, troauei de pacote, fiz macumba e nada. Lá pelas tantas, voltou a funcionar. Enquanto testava o DS e o MPV, parou de funcionar de novo. O VLC foi em promissor, mas eu achei a dcumentação falha e em alguns casos não tocou o vídeo (me surpreendeu!) e o principal fator decisivo para mim foi a questão tamanho (quase 70Mb) para baixar. Assim, nos meus testes o MPV foi o mais confiável, sem depender de codecs externos. Rodou todos os tipos de mídia (áudio e vídeo) com os recursos que eu preciso (mute, volume mais e menos, seek, pause, play, stop, informações - tamanho, duração, etc) e inclusive as funções de playback em outro termpo (mais acelerado ou mais lento) que em outros players não funcionava (e eu achava que era do codec ou to tipo de vídeo que não aceitava), funcionou blz tbm. Ainda estou efetuando testes em todas as máquinas que consigo por a mão. Quando vou em clientes, peço licença para rodar um teste com o MPV. Até agora, tem rodado tudo em todos os lugares. Não estou modificando nada, nem instalando nada. Só para verificar se os vídeos rodam independente do ambiente (Win7, Win8, Win10 32) todos 32 ou 64 bits, com ou sem codecs instalados. Somente assim, terei a certeza (relativa) de que vou me incomodar menos com a próxima versão, do que estou me incomodando agora! 99% por causa de arquivso que não tocam, provavelmente codecs. Mas não tem como ficar atendendo todo mundo, dando suporte mesmo quando vc instala um pacote de codecs e mesmo assim ora funciona ora não funciona. Novamente recomendo, por enquanto, o MPV. Em várias conversas e testes com o Belini (sim, conversamos bastante), infelizmente o MPV não funciona no caso dele em virtude do ambiente WIn XP, que já não é o meu caso. E aliás, o software do Belini, para quem não conhece, é um baita programa. Muito completo e bem-feito! Mas #FikaADika
×