SQLite - Möglichkeit Abfrage beschleunigen?

**BugFix**

Hi,

ich habe mir Free German Dictionary heruntergeladen und daraus eine SQLite Datenbank erstellt germandict.db (Tabelle: dictionary, Feld: word).

Die Datenbank möchte ich zum Überprüfen von Texten bzw. bei Teileingaben für Wortvorschläge nutzen. Dazu habe ich 3 Funktionen erstellt die per SELECT Statement auf Übereinstimmung am Wortanfang oder Wortende prüfen oder auf im Wort enthalten. Die Datenbank enthält ~1,9 Millionen Einträge und auf meinem Rechner dauert eine Abfrage dann ca. 3,5 s.

Lässt sich das evtl. noch beschleunigen?

Hier der Code, DB ist zu groß für den Anhang, DL hier:

AutoIt

 #include <SQLite.au3>

_SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)
Global $hSQL = _SQLite_Open(@ScriptDir & "\germandict.db")

Global $iTimer = TimerInit()
;~ $res = __SelectStartsWith(-1, 'dictionary', 'word', 'taxi')
;~ $res = __SelectEndsWith(-1, 'dictionary', 'word', 'taxi')
$res = __SelectContaining(-1, 'dictionary', 'word', 'taxi')
ConsoleWrite('Count: ' & @extended & @LF)
ConsoleWrite('Time: ' & TimerDiff($iTimer) & @CRLF)
ConsoleWrite("$res:" & @LF & $res & @LF)


Func __SelectStartsWith($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%s%%';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectEndsWith($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%%%s';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectContaining($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%%%s%%';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectFromWord($_hSQL, $_sSQL, $_sDelim=@CRLF)
    Local $aQuery, $hQuery, $sResult = '', $nRes = 0
    _SQlite_Query($_hSQL, $_sSQL, $hQuery)
    While _SQLite_FetchData($hQuery, $aQuery, False, False) = $SQLITE_OK
        $sResult &= $aQuery[0] & $_sDelim
        $nRes += 1
    WEnd
    _SQLite_QueryFinalize($hQuery)
    $sResult = $nRes > 0 ? StringTrimRight($sResult, StringLen($_sDelim)) : $sResult
    Return SetError(0,$nRes,$sResult)
EndFunc


_SQLite_Close($hSQL)
_SQLite_Shutdown()

Alles anzeigen

**alpines**

Eventuell wäre Parallelisierung noch eine Möglichkeit.

Da du keine JOINS in deinen Queries hast wird man da vermutlich nicht mehr viel machen können.

**AspirinJunkie**

Du verwendest Wildcards am Anfang und am Ende des Suchstrings.
Das führt zu einem Full Table Scan -> deshalb ist die Abfrage derart langsam.

Da die Wildcards vor und nach dem Suchwort stehen, bringt ein Index hier nichts (und auch spezielle Key-Value-Datenbanken wie z.B. Redis hätten das gleiche Problem).

Du kannst daher eigentlich nur versuchen die Ausführungsgeschwindigkeit zu erhöhen in dem du die Datenbank inmemory machst oder ähnliches.
Auch die Aktivierung des Exclusive-Modus wäre anzuraten (PRAGMA locking_mode=EXCLUSIVE;).

Alternativ gibt es dann noch Extensions welche diesen Sonderfall versuchen effektiver zu handeln: https://autoit.de

Hierzu müsstest du dir aber erst noch dein eigenes SQLite mit der entsprechenden Erweiterung kompilieren.

**BugFix**

Zitat von AspirinJunkie

in dem du die Datenbank inmemory machst oder ähnliches.

Ja, das hats gebracht!

Ich erstelle beim Skriptstart eine leere :memory: DB und binde die Wort-DB mit ATTACH an. Dann schaufele ich die Daten in die memory-DB (ca. 1,5 s). Das Abfragen aus der memory-DB dauert dann etwa 1 s oder weniger.

AutoIt

#include <SQLite.au3>

_SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)

; memory DB
Global $hSQL = _SQLite_Open()
_SQLite_Exec($hSQL, "CREATE TABLE dictionary (word TEXT);")

; file DB anbinden
Global $sAlias = "fileDB"
_SQLite_Exec($hSQL, StringFormat("ATTACH DATABASE '%s' AS %s", @ScriptDir & "\germandict.db", $sAlias))

; INSERT from file TO memory DB
Local $iTimer = TimerInit()
_SQLite_Exec($hSQL, "INSERT INTO dictionary SELECT * FROM fileDB.dictionary;")
;~ ConsoleWrite("Time INSERT INTO: " & TimerDiff($iTimer) & @CRLF)  ; ~ 1,5 s


Local $iTimer = TimerInit()
;~ $res = __SelectStartsWith(-1, 'dictionary', 'word', 'taxi')
;~ $res = __SelectEndsWith(-1, 'dictionary', 'word', 'taxi')
$res = __SelectContaining(-1, 'dictionary', 'word', 'taxi')
ConsoleWrite('Count: ' & @extended & @LF)
ConsoleWrite('Time: ' & TimerDiff($iTimer) & @CRLF)  ; < 1 s
ConsoleWrite("$res:" & @LF & $res & @LF)


Func __SelectStartsWith($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%s%%';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectEndsWith($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%%%s';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectContaining($_hSQL, $_sTable, $_sField, $_sValue, $_sDelim=@CRLF)
    Local $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '%%%s%%';", $_sField, $_sTable, $_sField, $_sValue)
    Local $sResult = __SelectFromWord($_hSQL, $sSQL, $_sDelim)
    Return SetError(0,@extended,$sResult)
EndFunc

Func __SelectFromWord($_hSQL, $_sSQL, $_sDelim=@CRLF)
    Local $aQuery, $hQuery, $sResult = '', $nRes = 0
    _SQlite_Query($_hSQL, $_sSQL, $hQuery)
    While _SQLite_FetchData($hQuery, $aQuery, False, False) = $SQLITE_OK
        $sResult &= $aQuery[0] & $_sDelim
        $nRes += 1
    WEnd
    _SQLite_QueryFinalize($hQuery)
    $sResult = $nRes > 0 ? StringTrimRight($sResult, StringLen($_sDelim)) : $sResult
    Return SetError(0,$nRes,$sResult)
EndFunc

Func __TableClearAll($_hSQL, $_sTable)
    Local $sSQL = StringFormat("FROM %s DELETE;", $_sTable)
    _SQLite_Exec($_hSQL, $sSQL)
EndFunc


_SQLite_Close($hSQL)
_SQLite_Shutdown()

Alles anzeigen

**Bitnugger**

Sehr schön - gute Idee - Danke!

Ich habe mir das Script noch ein wenig umgeschrieben... jetzt mit nur einer Funktion und die Suche kann nun auch "case sensitiv" sein.

PS: Den Fehler in der Funktion __TableClearAll hast du sicher schon bemerkt...

Edit: Habe das Script noch ein wenig gekürzt.

AutoIt

;-- TIME_STAMP   2018-04-23 23:56:11   v 0.1

#include <SQLite.au3>

Global $DEBUG = True

;~ Global $g_sAU3_Sharred_Files = EnvGet('AU3_Sharred_Files') ; F:\_Scripts\AutoIt\Shared files\
;~ ConsoleWrite("@@ Debug line" & @TAB & @ScriptLineNumber & "   var: $g_sAU3_Sharred_Files --> " & $g_sAU3_Sharred_Files & @CRLF)
;~ _SQLite_Startup($g_sAU3_Sharred_Files & "sqlite3.dll", False, 1)

_SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)

; memory DB
Global $hSQL = _SQLite_Open()
_SQLite_Exec($hSQL, "CREATE TABLE dictionary (word TEXT);")

; file DB anbinden
Global $sAlias = "fileDB"
_SQLite_Exec($hSQL, StringFormat("ATTACH DATABASE '%s' AS %s", @ScriptDir & "\germandict.db", $sAlias))

; INSERT from file DB TO memory DB
Global $hTimer = TimerInit()
_SQLite_Exec($hSQL, "INSERT INTO dictionary SELECT * FROM fileDB.dictionary;")
ConsoleWrite("Time INSERT INTO: " & TimerDiff($hTimer) & @CRLF & @CRLF)  ; ~ 1,5 s

Global $sSearch = 'Taxi', $sRes

Global Enum $eStartsWith = -1, $eContaining, $eEndsWith

$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eContaining, False)
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eContaining, True)

$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eStartsWith, False)
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eStartsWith, True)

$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eEndsWith, False)
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eEndsWith, True)

$sSearch = 'zz'
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eEndsWith, False)
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eEndsWith, True)

__TableClearAll(-1, 'dictionary')
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch, $eEndsWith, False)

_SQLite_Close($hSQL)
_SQLite_Shutdown()

Func __SQLite_SelectWord($_hSQL, $_sTable, $_sField, $_sValue, $_iSelect = 0, $_bSensitive = False, $_sDelim = @CRLF)
    Local $hTimer = TimerInit(), _
        $_sSelect = $_iSelect = -1 ? '%s%%' : $_iSelect = 1 ? '%%%s' : '%%%s%%', _
        $sResult, $aResult, $iRows, $iColumns, $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '"&$_sSelect&"';", $_sField, $_sTable, $_sField, $_sValue)
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & True)
    Local $iRval = _SQLite_GetTable($_hSQL, $sSQL, $aResult, $iRows, $iColumns), $iError = @error, $iExtended = @extended
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & False)
    If $DEBUG Then
        If $iRval = $SQLITE_OK Then $sResult = _ArrayToString($aResult, $_sDelim, 2)
        __PrintRes($sResult, $_iSelect, $_bSensitive, $iRows, $iError, $iExtended, TimerDiff($hTimer))
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, $sResult) : SetError($iError, $iExtended, $iRval)
    Else
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, _ArrayToString($aResult, $_sDelim, 2)) : SetError($iError, $iExtended, $iRval)
    EndIf
EndFunc   ;==>__SQLite_SelectWord

Func __TableClearAll($_hSQL, $_sTable)
    Local $sSQL = StringFormat("DELETE FROM %s;", $_sTable)
    If $DEBUG Then ConsoleWrite('! __TableClearAll: ' & $sSQL & @CRLF & @CRLF)
    Local $iRval = _SQLite_Exec($_hSQL, $sSQL)
EndFunc

Func __PrintRes($_sRes, $_iSelect, $_bSensitive, $_iCount, $_iError, $_iExtended, $_fDiffTime)
    If $_iError Then
        $_sRes = StringFormat('! #Error = %i \t #Extended = %i\r\n\r\n', $_sRes, $_iError, $_iExtended)
    Else
        $_sRes = '- ' & StringReplace($_sRes, @CRLF, ' ') & @CRLF & @CRLF
    EndIf
    Local $_sSelect = $_iSelect = -1 ? 'StartsWith' : $_iSelect = 0 ? 'Containing' : 'EndsWith', $_sSensitive = $_bSensitive ? 'True ' : 'False'
     ConsoleWrite(StringFormat('> __SQLite_SelectWord: $sSearch = %-32s | $_iSelect = %-10s | $_bSensitive = %s  | $_iCount = %5i | Time = %s\r\n%s', '"'&$sSearch&'"', $_sSelect, $_sSensitive, $_iCount, $_fDiffTime, $_sRes))
EndFunc

Alles anzeigen

**BugFix**

Zitat von Bitnugger

PS: Den Fehler in der Funktion __TableClearAll hast du sicher schon bemerkt...

War ein Aufmerksamkeitstest...

Den Gedanken alles in eine Funktion zu packen hatte ich am Anfang auch. Habe mich dann aber dagegen entschieden. Ist persönlicher Geschmack. Wenn möglich vermeide ich Funktionen mit einer Vielzahl Parameter und wrappe lieber in mehrere kurze Aufrufe.

Da habe ich noch einen Vorschlag, um die Parameterübergabe zu minimieren. Da Tabellen- und Feldname (zumindest in dieser Anwendungsform) bei jedem Aufruf identisch sind, ist es sinnvoll diese Beim erstmaligen Aufruf der Funktion zu übergeben. Danach kann man stattdessen -1 verwenden.

AutoIt

Func __SQLite_SelectWord($_hSQL, $_sTable = -1, $_sField = -1, $_sValue = '', $_iSelect = 0, $_bSensitive = False, $_sDelim = @CRLF)
    Local Static $sTable = Null, $sField = Null
    $sTable = $_sTable <> -1 ? $_sTable : $sTable
    $sField = $_sField <> -1 ? $_sField : $sField
    If $sTable = Null Or $sField = Null Then Return SetError($SQLITE_ERROR,0,'') 
    Local $hTimer = TimerInit(), _
        $_sSelect = $_iSelect = -1 ? '%s%%' : $_iSelect = 1 ? '%%%s' : '%%%s%%', _
        $sResult, $aResult, $iRows, $iColumns, $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '"&$_sSelect&"';", $sField, $sTable, $sField, $_sValue)
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & True)
    Local $iRval = _SQLite_GetTable($_hSQL, $sSQL, $aResult, $iRows, $iColumns), $iError = @error, $iExtended = @extended
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & False)
    If $DEBUG Then
        If $iRval = $SQLITE_OK Then $sResult = _ArrayToString($aResult, $_sDelim, 2)
        __PrintRes($sResult, $_iSelect, $_bSensitive, $iRows, $iError, $iExtended, TimerDiff($hTimer))
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, $sResult) : SetError($iError, $iExtended, $iRval)
    Else
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, _ArrayToString($aResult, $_sDelim, 2)) : SetError($iError, $iExtended, $iRval)
    EndIf
EndFunc   ;==>__SQLite_SelectWord

Alles anzeigen

**Bitnugger**

Zitat von BugFix

War ein Aufmerksamkeitstest...

Glaube ich dir aufs Wort... aber Vorsicht - denn nach dem 1001.ten Test musst du deinen Nick in @BugMaker ändern.

Zitat von BugFix

Den Gedanken alles in eine Funktion zu packen hatte ich am Anfang auch. Habe mich dann aber dagegen entschieden. Ist persönlicher Geschmack. Wenn möglich vermeide ich Funktionen mit einer Vielzahl Parameter und wrappe lieber in mehrere kurze Aufrufe.

Solange das Script noch gut überschaubar ist, mache ich es auch so... aber mit zunehmender Größe verschmelze ich dann gerne die (Mini-)Funktionen, soweit es sinnvoll ist.

Zitat von BugFix

Da habe ich noch einen Vorschlag, um die Parameterübergabe zu minimieren. Da Tabellen- und Feldname (zumindest in dieser Anwendungsform) bei jedem Aufruf identisch sind, ist es sinnvoll diese Beim erstmaligen Aufruf der Funktion zu übergeben. Danach kann man stattdessen -1 verwenden.

Ja, das ist eine gute Idee... habe es fast 1:1 übernommen... noch zwei Parameter ($_sValue und $_iSelect) hinzugenommen und damit auch gleich (m)einen blöden Fehler ($_sValue in Zeile 8 konnte "" sein) beseitigt.

Hier die korrigierte und erweiterte Version:

germandict.au3

AutoIt: germandict.au3

;-- TIME_STAMP   2018-04-24 16:19:26   v 1.1

#AutoIt3Wrapper_AU3Check_Parameters=-q -d -w 1 -w 2 -w 3 -w- 4 -w 5 -w 6 -w- 7

#include <SQLite.au3>

Global $DEBUG = True

Global $g_sAU3_Sharred_Files = EnvGet('AU3_Sharred_Files') ; F:\_Scripts\AutoIt\Shared files\
ConsoleWrite("@@ Debug line" & @TAB & @ScriptLineNumber & "   var: $g_sAU3_Sharred_Files --> " & $g_sAU3_Sharred_Files & @CRLF)
_SQLite_Startup($g_sAU3_Sharred_Files & "sqlite3.dll", False, 1)

;~ _SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)

; memory DB
Global $hSQL = _SQLite_Open()
_SQLite_Exec($hSQL, "CREATE TABLE dictionary (word TEXT);")

; file DB anbinden
Global $sAlias = "fileDB"
_SQLite_Exec($hSQL, StringFormat("ATTACH DATABASE '%s' AS %s", @ScriptDir & "\germandict.db", $sAlias))

; INSERT from file DB TO memory DB
Global $hTimer = TimerInit()
_SQLite_Exec($hSQL, "INSERT INTO dictionary SELECT * FROM fileDB.dictionary;")
ConsoleWrite("Time INSERT INTO: " & TimerDiff($hTimer) & @CRLF & @CRLF) ; ~ 1,5 s

Global $sSearch = 'Taxi', $sRes

Global Enum $eStartsWith = 1, $eContaining, $eEndsWith = 4 ; Default = $eContaining (2)

; Beim ersten Aufruf von __SQLite_SelectWord müssen die optionalen Parameter $_sTable bis $_sValue korrekt angegeben werden, danach reicht ein -1!
$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', '') ; , $sSearch, $eContaining, False) <-- #Error = 8 - Wrong parameter(s); $_sValue bzw. $sSearch = ''

$sRes = __SQLite_SelectWord(-1, 'dictionary', 'word', $sSearch) ; , $eContaining, False)
$sRes = __SQLite_SelectWord(-1, -1, -1, -1, -1, True)

$sRes = __SQLite_SelectWord(-1, -1, -1, -1, $eStartsWith)
$sRes = __SQLite_SelectWord(-1, -1, -1, -1, -1, True)

$sRes = __SQLite_SelectWord(-1, -1, -1, -1, $eEndsWith)
$sRes = __SQLite_SelectWord(-1, -1, -1, -1, -1, True)

$sSearch = 'zz'
$sRes = __SQLite_SelectWord(-1, -1, -1, $sSearch, $eStartsWith)
$sRes = __SQLite_SelectWord(-1, -1, -1, -1, $eEndsWith)

__TableClearAll(-1, 'dictionary')
$sRes = __SQLite_SelectWord(-1)

_SQLite_Close($hSQL)
_SQLite_Shutdown()

Func __SQLite_SelectWord($_hSQL, $_sTable = -1, $_sField = -1, $_sValue = -1, $_iSelect = -1, $_bSensitive = False, $_sDelim = @CRLF)
    Local Static $sTable = Null, $sField = Null, $sValue = Null, $iSelect = Null
    $sTable = $_sTable = -1 ? $sTable : $_sTable
    $sField = $_sField = -1 ? $sField : $_sField
    $sValue = ($_sValue = -1 Or $_sValue = '') ? $sValue : $_sValue
    Switch $_iSelect
        Case -1
            $iSelect = $iSelect = Null ? 2 : $iSelect
        Case 1, 2, 4
            $iSelect = $_iSelect
        Case Else
            $iSelect = Null
    EndSwitch
    Local $hTimer = TimerInit(), _
        $sSelect = $iSelect = 1 ? '%s%%' : $iSelect = 2 ? '%%%s%%' : '%%%s', _
        $sResult, $aResult, $iRows, $iColumns, $sSQL = StringFormat("SELECT %s FROM %s WHERE %s LIKE '"&$sSelect&"';", $sField, $sTable, $sField, $sValue)
    If $sTable = Null Or $sField = Null Or $sValue = Null Or $iSelect = Null Then Return SetError(8, 0 , (__PrintRes('Wrong parameter(s)', $sValue, $iSelect, $_bSensitive, 0, 8, 0, TimerDiff($hTimer))))
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & True)
    Local $iRval = _SQLite_GetTable($_hSQL, $sSQL, $aResult, $iRows, $iColumns), $iError = @error, $iExtended = @extended
    If $_bSensitive Then _SQLite_Exec($hSQL, 'PRAGMA case_sensitive_like = ' & False)
    If $DEBUG Then
        If $iRval = $SQLITE_OK Then $sResult = _ArrayToString($aResult, $_sDelim, 2)
        __PrintRes($sResult, $sValue, $iSelect, $_bSensitive, $iRows, $iError, $iExtended, TimerDiff($hTimer))
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, $sResult) : SetError($iError, $iExtended, $iRval)
    Else
        Return $iRval = $SQLITE_OK ? SetError(0, $iRows, _ArrayToString($aResult, $_sDelim, 2)) : SetError($iError, $iExtended, $iRval)
    EndIf
EndFunc   ;==>__SQLite_SelectWord

Func __TableClearAll($_hSQL, $_sTable)
    Local $sSQL = StringFormat("DELETE FROM %s;", $_sTable)
    Local $iRval = _SQLite_Exec($_hSQL, $sSQL)
    If $DEBUG Then ConsoleWrite('! __TableClearAll: ' & $sSQL & ' = ' & $iRval & @CRLF & @CRLF)
EndFunc   ;==>__TableClearAll

Func __PrintRes($_sRes, $_sValue, $_iSelect, $_bSensitive, $_iCount, $_iError, $_iExtended, $_fDiffTime)
    If $_iError Then
        $_sRes = StringFormat('! %-18s \t #Error = %i \t #Extended = %i\r\n\r\n', $_sRes, $_iError, $_iExtended)
    Else
        $_sRes = '- ' & StringReplace($_sRes, @CRLF, ' ') & @CRLF & @CRLF
    EndIf
    Local $_sSelect = $_iSelect = 1 ? 'StartsWith' : $_iSelect = 2 ? 'Containing' : 'EndsWith', $_sSensitive = $_bSensitive ? 'True ' : 'False'
    ConsoleWrite(StringFormat('> __SQLite_SelectWord: $_sValue = %-32s | $_iSelect = %-10s | $_bSensitive = %s  | $_iCount = %5i | Time = %s\r\n%s', '"' & $_sValue & '"', $_sSelect, $_sSensitive, $_iCount, $_fDiffTime, $_sRes))
EndFunc   ;==>__PrintRes

Alles anzeigen

PS: Da könnte man jetzt auch noch leicht weitere Dictionarys hinzufügen... z.B. Englisch, Klingonisch, ...

Banana_2_Day

BugFix

Kannst Du die Datei bitte erneut hochladen?

http://www.filedropper.com/germandict

Vielleicht hat diese auch jemand von Euch zur Hand?

**BugFix**

Zitat von Banana_2_Day

Kannst Du die Datei bitte erneut hochladen?

Ich nehme an, du meinst die db-Datei. Hier: https://we.tl/t-eFzg2ifUxQ

Banana_2_Day

Zitat von BugFix

Ich nehme an, du meinst die db-Datei. Hier: https://we.tl/t-eFzg2ifUxQ

Vielen Dank, ja die Datei meinte ich.

Testlauf erfolgreich und schnell

Weißt Du noch, wie / mit welchem Programm Du damals die SQLite Datenbank erzeugt hast?

Was ist ein guter SQLite Datenbank Viewer unter Windows 8 - 10?

Möchte mir die "germandict.db" im Original anschauen.

**Bitnugger**

Zitat von Banana_2_Day

Was ist ein guter SQLite Datenbank Viewer unter Windows 8 - 10?

Ich benutze den hier: https://sqlitebrowser.org/blog/version-3-12-2-released/

Banana_2_Day

Zitat von Bitnugger

Ich benutze den hier: https://sqlitebrowser.org/blog/version-3-12-2-released/

Ausprobiert und Danke , der Browser arbeitet fast so schnell wie der Code von Bugfix

**BugFix**

EDIT:

Ich muss nochmal über das Skript drüberschauen. Aus irgendeinem Grund wurde die DB nicht gespeichert. Melde mich wenn korrigiert.

Möglicherweise sind in der aktuellen Version (habe ich eben zum ersten mal genutzt) Änderungen in den internen Funktionen, die die SQLite.au3 nicht kennt. Mal durchgraben.

EDIT 2:

Fehler gefunden: UNBEDINGT die 32-bit Version verwenden.

Zitat von Banana_2_Day

Weißt Du noch, wie / mit welchem Programm Du damals die SQLite Datenbank erzeugt hast?

Na mit AutoIt!

Habe das Skript zwar nicht mehr gehabt, aber schnell nochmal erstellt:

AutoIt: FreeGermanDict_CreateDB.au3

#include <File.au3>
#include <SQLite.au3>


; ACHTUNG! Für die verwendete INSERT-Syntax ist mindestens die SQLite-Version 3.7.11 erforderlich!!!

; "sqlite3.dll" muss im Skriptordner liegen
; DL aktuelle DLL: "https://www.sqlite.org/download.html" Abschnitt: "Precompiled Binaries for Windows"
_SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)   ; version 3.36.0


; HIER PFAD ANPASSEN - entpackter Ordner "german.7z"  (DL: https://sourceforge.net/projects/germandict/)
Global $sPathGER = @ScriptDir & '\german_2021'

; Text-Dateien (außer "LiesMich.txt") aus diesem Ordner in Array einlesen
; Array Dimension ggf. vergrößern - Anzahl steht auf DL-Seite (z.Zt. > 2 Mio)
Global $aWords[2500000], $iCount = 0


; Zeitmessung
Global $Timer = TimerInit()

; Array mit den Textdateien
Global $aTxtFiles = _FileListToArray($sPathGER, '*.*', 1)

Global $aTxt
For $i = 1 To $aTxtFiles[0]
    If $aTxtFiles[$i] = "LiesMich.txt" Or _
       (Not StringInStr('.txt .dic', StringRight($aTxtFiles[$i], 4))) Then ContinueLoop

    ConsoleWrite('READING FILE: ' & $sPathGER & '\' & $aTxtFiles[$i] & @CRLF)
    $aTxt = FileReadToArray($sPathGER & '\' & $aTxtFiles[$i])
    For $j = 0 To UBound($aTxt) -1
        If $aTxt[$j] = '' Then ContinueLoop  ; evtl. Leerzeile abfangen
        $aWords[$iCount] = $aTxt[$j]
        $iCount += 1
    Next
Next
ReDim $aWords[$iCount]

ConsoleWrite('FERTIG - Array, Anzahl: ' & $iCount & @CRLF)

; SQLite-DB erstellen
Global $hSQL = _SQLite_Open(@ScriptDir & '\germandict.db')

; DB-Tabelle erstellen - hat nur ein Feld: word
_SQLite_Exec($hSQL, 'CREATE TABLE dictionary (word TEXT);')

ConsoleWrite('BEFÜLLEN SQLite-Table' & @CRLF)
; alle Item aus $aWords in die DB-Tabelle übertragen
; INSERT-Strings erstellen und einmalig ausführen (einzelner INSERT ist nicht möglich - Datenmenge zu groß)
; SQLITE_MAX_SQL_LENGTH = 1.000.000 bytes - ich prüfe auf > 900.000
Global $currIndex = 0, $iLen = 0, $sSQL, $sEndChar

While $currIndex < UBound($aWords) -1
    $sSQL = 'INSERT INTO dictionary (word) VALUES '
    For $i = $currIndex To UBound($aWords) -1
        $iLen += StringLen('("' & $aWords[$i] & '"),')
        $sEndChar = ($i = UBound($aWords) -1 Or $iLen > 900000) ? ';' : ','
        $sSQL &= '("' & $aWords[$i] & '")' & $sEndChar
        If $sEndChar = ';' Then
            $currIndex = $i +1
            $iLen = 0
            _SQLite_Exec($hSQL, 'BEGIN TRANSACTION;' & $sSQL & 'COMMIT;')
            ExitLoop
        EndIf
    Next
WEnd

_SQLite_Shutdown()

ConsoleWrite('FERTIG - germandict.db, Dauer Erstellung: ' & StringFormat('%.1f s', TimerDiff($Timer)/1000) & @CRLF)

Alles anzeigen

Bei mir auf dem Laptop hat es rund 30 Sekunden gebraucht.

**BugFix**

Zitat von BugFix

Ich erstelle beim Skriptstart eine leere :memory: DB und binde die Wort-DB mit ATTACH an. Dann schaufele ich die Daten in die memory-DB (ca. 1,5 s).

So, mit neuen Funktionen in der sqlite3.dll kann man das deutlich beschleunigen: Jetzt nur noch 0,1 Sekunden!!

Statt mit INSERT die DS rüberzuschaufeln kann man jetzt die "sqlite3_backup_..." Funktionen nutzen. Da in der SQLite.au3 noch nicht enthalten, habe ich diese mal erstellt.

~~Das Abfangen der Return-SQL-Codes aus der Init-Funktion ist mir nicht klar. Aber bei sauber übergebenen Parametern ist das ohne Problem.~~ Gelöst, s. hier.

Hier die Anwendung mit der "germandict.db":

AutoIt

#include <SQLite.au3>

_SQLite_Startup(@ScriptDir & "\sqlite3.dll", False, 1)

; source
Global $sDBFile = @ScriptDir & "\germandict.db"
; destination
Global $hDBMem = -1  ; -1=kopiert aus Datei in Memory-DB

Global $Timer = TimerInit()
_SQLite_Backup_LoadOrSaveDB($sDBFile, $hDBMem) ; kopiert aus Datei in Memory
ConsoleWrite('Kopierzeit File -> Memory: ' & StringFormat('%.1f s', TimerDiff($Timer)/1000) & @CRLF)

;~ ; Test_1 - SELECT aus Memory-DB (alle Wörter, die mit "aus" beginnen)
ConsoleWrite(__SelectFromWord($hDBMem, "SELECT word FROM dictionary WHERE word LIKE 'aus%';")  & @CRLF)

; Test_2 - Rückschreiben aus Menmory-DB in neue DB-Datei
$Timer = TimerInit()
_SQLite_Backup_LoadOrSaveDB(@ScriptDir & "\germandict_copy.db", $hDBMem) ; kopiert aus Memory in Datei, da $hDBMem jetzt ungleich -1
ConsoleWrite('Kopierzeit Memory -> File: ' & StringFormat('%.1f s', TimerDiff($Timer)/1000) & @CRLF)

_SQLite_Shutdown()


Func __SelectFromWord($_hSQL, $_sSQL, $_sDelim=@CRLF)
    Local $aQuery, $hQuery, $sResult = '', $nRes = 0
    _SQlite_Query($_hSQL, $_sSQL, $hQuery)
    While _SQLite_FetchData($hQuery, $aQuery, False, False) = $SQLITE_OK
        $sResult &= $aQuery[0] & $_sDelim
        $nRes += 1
    WEnd
    _SQLite_QueryFinalize($hQuery)
    $sResult = $nRes > 0 ? StringTrimRight($sResult, StringLen($_sDelim)) : $sResult
    Return SetError(0,$nRes,$sResult)
EndFunc


Func _SQLite_Backup_LoadOrSaveDB($_FileDB, ByRef $_MemDB) ; default ($_MemDB mit -1 übergeben): save from file to memory
    Local $pFile = _SQLite_Open($_FileDB)
    If @error Then Return SetError(@error,0,0)
    Local $bSaveToFile = True, $iRet, $pBackup, $pTo, $pFrom
    If $_MemDB = -1 Then
        $bSaveToFile = False
        $_MemDB = _SQLite_Open()
    EndIf
    $pFrom = $bSaveToFile ? $_MemDB : $pFile
    $pTo = $bSaveToFile ? $pFile : $_MemDB
    $pBackup = _SQLite_Backup_Init($pTo, "main", $pFrom, "main")
    If @extended = $SQLITE_OK Then
        _SQLite_Backup_Step($pBackup)
        _SQLite_Backup_Finish($pBackup)
        $iRet = _SQLite_ErrCode()
    Else
        Return SetError(1,@extended,0)
    EndIf
    _SQLite_Close($pFile)
    Return $iRet
EndFunc


Func _SQLite_Backup_Init($_pTo, $_NameToDB, $_pFrom, $_NameFromDB)
    Local $aRet = DllCall($__g_hDll_SQLite, "int:cdecl", "sqlite3_backup_init", _
            "ptr", $_pTo, _         ; Database Connection Handle associated with the destination database.
            "str", $_NameToDB, _     ; Database Name associated with the destination database. ("main", "temp" or AS-name from ATTACH statement)
            "ptr", $_pFrom, _         ; Database Connection Handle associated with the source database.
            "str", $_NameFromDB)     ; Database Name associated with the source database. ("main", "temp" or AS-name from ATTACH statement)
    If Not @error Then
        Return SetError(0,$SQLITE_OK,$aRet[0])             ; The sqlite3_backup object
    Else
        Return SetError(1,0,$SQLITE_ERROR)
    EndIf
EndFunc


Func _SQLite_Backup_Step($_pBackup, $_nPages=-1)
    Local $aRet = DllCall($__g_hDll_SQLite, "int:cdecl", "sqlite3_backup_step", _
            "ptr", $_pBackup, _        ; The sqlite3_backup object
            "int", $_nPages)        ; Number of pages to be copied.
    If Not @error Then
        If $aRet[0] <> $SQLITE_DONE Or $aRet[0] <> $SQLITE_OK Then Return SetError(1,0,$aRet[0])
        Return $aRet[0]
    Else
        Return SetError(1,0,$SQLITE_ERROR)
    EndIf
EndFunc


Func _SQLite_Backup_Finish($_pBackup)
    Local $aRet = DllCall($__g_hDll_SQLite, "int:cdecl", "sqlite3_backup_finish", _
            "ptr", $_pBackup)        ; The sqlite3_backup object
    If Not @error Then
        Return $aRet[0]
    Else
        Return SetError(1,0,$SQLITE_ERROR)
    EndIf
EndFunc

Alles anzeigen