#NoTrayIcon
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_icon=CompSQLite.ico
#AutoIt3Wrapper_Compression=4
#AutoIt3Wrapper_UseX64=n
#AutoIt3Wrapper_Res_Fileversion=1.1.0.0
#AutoIt3Wrapper_Res_Language=1036
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#cs ---------------------------------------------------------------------------

	CompSQLite - Comparaison de Bases SQLite
	Script AutoIt Version 3.3.6.1

	Auteur : Ahbadiane
	Septembre-Octobre 2010

	BUG :
	-

	ToDo :
	-

	Historique :
	- 04 Octobre 2010 - Version 1.0.1.0 - Première version publiée sur www.autoitscript.fr
	- 26 Octobre 2010 - Version 1.1.0.0 - 2 Bugs corrigés et 6 nouveautés

#ce ---------------------------------------------------------------------------

#Region - Déclaration
#include <ButtonConstants.au3>
#include <ComboConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
#include <GuiComboBoxEx.au3>
#include <SQLite.au3>
#include <SQLite.dll.au3>

;--------------------------------------------------------------------------------------------------------------------------------
; Déclarations
Global $iEtape = 0
Global $sBaseRef, $sBaseComp
Global $hBaseRef, $hBaseComp
Global $sListeTableBaseRef[1], $sListeTableBaseComp[1]
Global $NbLigneRapport = 0
Global $sRapport[1][5] ; 0=Erreur O/N, 1=Table, 2=Info, 3=Valeur Base de Référence, 4=Valeur Base Comparée
Global Const $sListeAnalyse[4] = ["Analyse de la structure uniquement de la table", "Analyse de la liste des enregistrements (clés uniquement)", "Analyse exhaustive des enregistrements (Clés et donnèes)","Ne pas analyser cette table"]

;--------------------------------------------------------------------------------------------------------------------------------
; Interface
Global $FormCompSqlite = GUICreate("Comparaison de deux bases Sqlite - By Ahbadiane", 733, 197, -1, -1, -1, BitOR($WS_EX_ACCEPTFILES,$WS_EX_WINDOWEDGE))
GUISetBkColor(0xA6CAF0)
Global $LabelBaseRef = GUICtrlCreateLabel("Base de référence", 16, 24, 91, 17)
Global $InputBaseRef = GUICtrlCreateInput("", 112, 21, 530, 21)
Global $ButtonChercheBaseRef = GUICtrlCreateButton("Recherche", 648, 19, 75, 25, $WS_GROUP)
Global $ButtonSwap = GUICtrlCreateButton("éê", 40, 42, 26, 20, $WS_GROUP)
GUICtrlSetFont(-1, 7, 400, 0, "Wingdings")
Global $LabelBaseComp = GUICtrlCreateLabel("Base comparée", 16, 64, 78, 17)
Global $InputBaseComp = GUICtrlCreateInput("", 112, 61, 530, 21)
Global $ButtonChercheBaseComp = GUICtrlCreateButton("Recherche", 648, 59, 75, 25, $WS_GROUP)
Global $LabelInfo = GUICtrlCreateLabel("Information à mettre à jour à chaque étape", 382, 100, 340, 12, $SS_CENTER)
GUICtrlSetFont(-1, 8, 400, 0, "Calibri")
GUICtrlSetColor(-1, 0x434E54)
Global $LabelTableRef = GUICtrlCreateLabel("Table Référence", 16, 116, 84, 17)
Global $InputTableRef = GUICtrlCreateInput("", 112, 113, 260, 21)
GUICtrlSetFont(-1, 8, 800, 0, "MS Sans Serif")
GUICtrlSetState(-1, $GUI_DISABLE)
Global $ComboAnalyse = GUICtrlCreateCombo("", 381, 113, 342, 25, BitOR($CBS_DROPDOWNLIST,$CBS_AUTOHSCROLL))
Global $ButtonEtapeUne = GUICtrlCreateButton("< Première étape ", 480, 158, 115, 25, $WS_GROUP)
Global $ButtonSuiv = GUICtrlCreateButton("Etape Suivante >", 608, 158, 115, 25, $WS_GROUP)
Global $LabelVersion = GUICtrlCreateLabel("", 16, 172, 95, 17)
GUICtrlSetColor(-1, 0x646464)

;--------------------------------------------------------------------------------------------------------------------------------
; Démarrage
GUICtrlSetState($LabelBaseRef, $GUI_DROPACCEPTED)
GUICtrlSetState($InputBaseRef, $GUI_DROPACCEPTED)
GUICtrlSetState($LabelBaseComp, $GUI_DROPACCEPTED)
GUICtrlSetState($InputBaseComp, $GUI_DROPACCEPTED)
GUICtrlSetData($LabelVersion, "Version " & FileGetVersion(@ScriptDir & "\" & StringLeft(@ScriptName, StringLen(@ScriptName) - 4) & ".exe"))
MettreChoixAnalyse(0)
ModeEtape0()
; Noms de fichiers passés sous forme de paramètre
If $CmdLine[0] >= 1 Then
	GUICtrlSetData($InputBaseRef, $CmdLine[1])
	If $CmdLine[0] >= 2 Then GUICtrlSetData($InputBaseComp, $CmdLine[2])
Else
	GUICtrlSetData($InputBaseRef, LireIni("DB", "DB-Ref", ""))
	GUICtrlSetData($InputBaseComp, LireIni("DB", "DB-Comp", ""))
EndIf
GUISetState(@SW_SHOW)
_SQLite_Startup()

;--------------------------------------------------------------------------------------------------------------------------------
; Boucle principale
While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			ExitLoop
		Case $GUI_EVENT_DROPPED
			Switch @GUI_DROPID
			Case $LabelBaseRef, $InputBaseRef
				GUICtrlSetData($InputBaseRef, @GUI_DRAGFILE)
			Case $LabelBaseComp, $InputBaseComp
				GUICtrlSetData($InputBaseComp, @GUI_DRAGFILE)
			EndSwitch
		Case $ButtonEtapeUne
			ModeEtape0()
		Case $ButtonSuiv
			AvanceEtape()
		Case $ButtonChercheBaseRef
			$sBaseRef = FileOpenDialog("Rechercher la base de référence", DossierParDefaut(GUICtrlRead($InputBaseRef), @ScriptDir), "Fichier Sqlite (*.db;*.db3;*.sqlite)|Tous les fichiers (*.*)", 3)
			If @error <> 1 Then GUICtrlSetData($InputBaseRef, $sBaseRef)
		Case $ButtonChercheBaseComp
			$sBaseComp = FileOpenDialog("Rechercher la base de référence", DossierParDefaut(GUICtrlRead($InputBaseComp), @ScriptDir), "Fichier Sqlite (*.db;*.db3;*.sqlite)|Tous les fichiers (*.*)", 3)
			If @error <> 1 Then GUICtrlSetData($InputBaseComp, $sBaseComp)
		Case $ButtonSwap
			$sBaseComp = GUICtrlRead($InputBaseComp)
			$sBaseRef =  GUICtrlRead($InputBaseRef)
			GUICtrlSetData($InputBaseRef, $sBaseComp)
			GUICtrlSetData($InputBaseComp, $sBaseRef)
	EndSwitch
WEnd

; Fermer les bases & SQlite
_SQLite_Close($hBaseRef)
_SQLite_Close($hBaseComp)
_SQLite_Shutdown()

Exit


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction principale d'analyse de la base de Référence VS la la base Comparée
;
; IN  $iTable : N° de la table de référence analysée (1 à ...)
; OUT True l'analyse à été complète, False sinon
;--------------------------------------------------------------------------------------------------
Func Analyse($iTable)
	Local $vData, $vData2, $sSql, $sSql2, $sSqlExe, $sIndex, $hQuery, $i, $s, $iAnalyse, $vListeColonnes, $iNbColonnes, $bPb
	Local $sPrimaryKey = "", $sIndexUnique = "", $sIndexSimple = "", $sLiteCles, $sTableauCles, $sOrderBy, $sWhere, $sValCle
	; ----- Choix de l'analyse --------------------------------------------------------------------------------------------------
	$iAnalyse = ConnaitreChoixAnalyse()
	;
	If $iAnalyse = 3 Then ; pas d'analyse
		RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Table non analysée")
		Return True
	EndIf
	;
	; ----- Comparaison de la struture de la table ------------------------------------------------------------------------------
	If _SQLite_QuerySingleRow($hBaseRef, "SELECT sql FROM sqlite_master WHERE type='table' AND tbl_name='" & $sListeTableBaseRef[$iTable] & "';", $vData) <> $SQLITE_OK Then
		RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Recherche de la table dans la base de référence", "ERREUR GRAVE : Pas trouvée !")
		Return False
	Else
		$sSql = $vData[0]
	EndIf
	If _SQLite_QuerySingleRow($hBaseComp, "SELECT sql FROM sqlite_master WHERE type='table' AND tbl_name='" & $sListeTableBaseRef[$iTable] & "';", $vData) <> $SQLITE_OK Then
		RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Recherche de la table dans la base Comparée", "Table non trouvée")
		Return False
	Else
		If $sSql <> $vData[0] Then
			RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Struture de la table différente", $sSql, $vData[0])
		Else
			RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Struture des 2 tables identiques", $sSql, $vData[0])
		EndIf
	EndIf
	;
	; ----- PRIMARY KEY ? -------------------------------------------------------------------------------------------------------
	$i = StringInStr($sSql, " PRIMARY KEY (", 1)
	If $i > 0 Then
		$sPrimaryKey = StringMid($sSql, $i + 14)
		$sPrimaryKey = Stringleft($sPrimaryKey, StringInStr($sPrimaryKey, ")") - 1)
	EndIf
	;
	; ----- Comparaison des index de la table REF vers la table COMP ------------------------------------------------------------
	_SQlite_Query($hBaseRef, "SELECT name, Sql FROM sqlite_master WHERE tbl_name= '" & $sListeTableBaseRef[$iTable] & "' AND type='index';", $hQuery)
	While _SQLite_FetchData($hQuery, $vData) = $SQLITE_OK
		$sIndex = $vData[0]
		$sSql = $vData[1]
		If StringLeft($sIndex, 17) <> "sqlite_autoindex_" Then
			If $sIndexSimple = "" Then
				$sIndexSimple = StringMid($sSql, StringInStr($sSql, "(") + 1)
				$sIndexSimple = Stringleft($sIndexSimple, StringInStr($sIndexSimple, ")") - 1)
			EndIf
			If _SQLite_QuerySingleRow($hBaseComp, "SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name='" & $sListeTableBaseRef[$iTable] & "' AND name='" & $sIndex & "';", $vData) <> $SQLITE_OK Then
				RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Index [" & $sIndex & "] non trouvé dans la base Comparée", $sSql, "")
			Else
				If $sSql <> $vData[0] Then
					RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Struture de l'index [" & $sIndex & "] différent", $sSql, $vData[0])
				Else
					RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Struture de l'index [" & $sIndex & "] est identique pour les 2 tables", $sSql, $vData[0])
				EndIf
				; Index Unique
				If $sIndexUnique = "" Then
					$i = StringInStr($sSql, "CREATE UNIQUE INDEX ")
					If $i > 0 Then
						$sIndexUnique = StringMid($sSql, StringInStr($sSql, "(") + 1)
						$sIndexUnique = Stringleft($sIndexUnique, StringInStr($sIndexUnique, ")") - 1)
					EndIf
				EndIf
			EndIf
		EndIf
	WEnd
	_SQLite_QueryFinalize($hQuery)
	;
	; ------ Comparaison des index de la table de COMP vers la table REF --------------------------------------------------------
	$bPb = False
	_SQlite_Query($hBaseComp, "SELECT name, Sql FROM sqlite_master WHERE tbl_name= '" & $sListeTableBaseRef[$iTable] & "' AND type='index' ORDER BY name ASC;", $hQuery)
	While _SQLite_FetchData($hQuery, $vData) = $SQLITE_OK
		If _SQLite_QuerySingleRow($hBaseRef, "SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name='" & $sListeTableBaseRef[$iTable] & "' AND name='" & $vData[0] & "';", $vData2) <> $SQLITE_OK Then
			RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Index supplémentaire dans la base Comparée : " &$vData[0], "", $vData[1])
			$bPb = True
		EndIf
	WEnd
	_SQLite_QueryFinalize($hQuery)
	If Not $bPb Then RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Pas d'index supplémentaire dans la base Comparée")
	;
	If $iAnalyse = 0 Then Return True
	;
	; ----- Comparer les clés et même les enregistrements -----------------------------------------------------------------------
	; Liste des colonnes
	_SQlite_Query($hBaseRef, "SELECT * FROM " & NomSql($sListeTableBaseRef[$iTable]) & ";", $hQuery)
	If _SQLite_FetchNames($hQuery, $vListeColonnes)<> $SQLITE_OK Then
		RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Noms des colonnes de la base de Référence", "ERREUR GRAVE : non accessible !")
		Return False
	EndIf
	_SQLite_QueryFinalize($hQuery)
	$iNbColonnes = UBound($vListeColonnes)
	; Cle de recherche
	$sLiteCles = "[" & $vListeColonnes[0] & "]"
	If StringInStr($sLiteCles, "[") = 0 Then $sLiteCles = "[" & $sLiteCles & "]"
	If $sIndexSimple > "" Then $sLiteCles = $sIndexSimple
	If $sIndexUnique > "" Then $sLiteCles = $sIndexUnique
	If $sPrimaryKey > "" Then $sLiteCles = $sPrimaryKey
	$sTableauCles = StringSplit($sLiteCles, ",")
	; Sql de recherche
	$sOrderBy = " ORDER BY "
	$sWhere = " WHERE "
	For $i = 1 To $sTableauCles[0]
		$sOrderBy &= StringStripWS($sTableauCles[$i], 3) & " ASC"
		If $i = $sTableauCles[0] Then
			$sOrderBy &= ";"
		Else
			$sOrderBy &= ", "
		EndIf
		$sWhere &= StringStripWS($sTableauCles[$i], 3) & "='" & Chr(1) & $i & Chr(1) & "'"
		If $i = $sTableauCles[0] Then
			$sWhere &= ";"
		Else
			$sWhere &= " AND "
		EndIf
	Next
	If $iAnalyse = 1 Then
		$sSql = "SELECT " & $sLiteCles & " FROM " & NomSql($sListeTableBaseRef[$iTable]) & $sOrderBy
		$sSql2 = "SELECT " & $sLiteCles & " FROM " & NomSql($sListeTableBaseRef[$iTable]) & $sWhere
	Else
		$sSql = "SELECT * FROM " & NomSql($sListeTableBaseRef[$iTable]) & $sOrderBy
		$sSql2 = "SELECT * FROM " & NomSql($sListeTableBaseRef[$iTable]) & $sWhere
	EndIf
	; Analyse des enregistrements
	$bPb = False
	_SQlite_Query($hBaseRef, $sSql, $hQuery)
	While _SQLite_FetchData($hQuery, $vData) = $SQLITE_OK
		$sSqlExe = $sSql2
		For $i = 1 To $sTableauCles[0]
			$sSqlExe = StringReplace($sSqlExe, Chr(1) & $i & Chr(1), Quote($vData[$i - 1]))
		Next
		$sValCle = StringMid($sSqlExe, StringInStr($sSqlExe, "WHERE ") + 6)
		$sValCle = StringLeft($sValCle, StringLen($sValCle) - 1)
		If _SQLite_QuerySingleRow($hBaseComp, $sSqlExe, $vData2) <> $SQLITE_OK Then
			RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Enregistrement non trouvé dans la table Comparée ", $sValCle)
			$bPb = True
		Else
			If $iAnalyse = 2 Then
				For $i = 0 To $iNbColonnes - 1
					If $vData[$i] <> $vData2[$i] Then
						RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Enregistrement différent pour " & $sValCle, $vData[$i], $vData2[$i])
						$bPb = True
					EndIf
				Next
			EndIf
		EndIf
	WEnd
	_SQLite_QueryFinalize($hQuery)
	If Not $bPb Then
		$sValCle = StringMid($sSql2, StringInStr($sSql2, "WHERE ") + 6)
		For $i = 1 To $sTableauCles[0]
			$sValCle = StringReplace($sValCle, Chr(1) & $i & Chr(1), "")
		Next
		$sValCle = StringReplace($sValCle, "''", "")
		$sValCle = StringReplace($sValCle, "=", "")
		$sValCle = StringReplace($sValCle, ";", "")
		$sValCle = StringReplace($sValCle, "AND", ",")
		If $iAnalyse = 1 Then
			RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "La liste des clés est identique dans les 2 tables", $sValCle)
		Else
			RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Le contenu des enregistrement est identique dans les 2 tables", $sValCle)
		EndIf
	EndIf
	; ----- Recherche des enregistrements en plus dans la base Comparée ---------------------------------------------------------
	$bPb = False
	_SQlite_Query($hBaseComp, $sSql, $hQuery)
	While _SQLite_FetchData($hQuery, $vData) = $SQLITE_OK
		$sSql = $sSql2
		For $i = 1 To $sTableauCles[0]
			$sSql = StringReplace($sSql, Chr(1) & $i & Chr(1), Quote($vData[$i - 1]))
		Next
		$sValCle = StringMid($sSql, StringInStr($sSql, "WHERE ") + 6)
		$sValCle = StringLeft($sValCle, StringLen($sValCle) - 1)
		If _SQLite_QuerySingleRow($hBaseRef, $sSql, $vData2) <> $SQLITE_OK Then
			RapportAjouterLigne(True, $sListeTableBaseRef[$iTable], "Enregistrement en plus dans la table Comparée ", "", $sValCle)
			$bPb = True
		EndIf
	WEnd
	_SQLite_QueryFinalize($hQuery)
	If Not $bPb Then RapportAjouterLigne(False, $sListeTableBaseRef[$iTable], "Pas d'enregistrement en plus dans la Table Comparée")
	;
	Return True
EndFunc


Func AnalyseTableEnPlusBaseComp()
	Local $iComp, $iRef, $bPb, $vData, $bPbGen = False
	For $iComp = 1 To $sListeTableBaseComp[0]
		$bPb = True
		For $iRef = 1 To $sListeTableBaseRef[0]
			If $sListeTableBaseComp[$iComp] = $sListeTableBaseRef[$iRef] Then
				$bPb = False
				ExitLoop
			EndIf
		Next
		If $bPb Then
			$bPbGen = True
			If _SQLite_QuerySingleRow($hBaseComp, "SELECT sql FROM sqlite_master WHERE type='table' AND tbl_name='" & $sListeTableBaseComp[$iComp] & "';", $vData) <> $SQLITE_OK Then _
				Dim $vData[1]
			RapportAjouterLigne(True, $sListeTableBaseComp[$iComp], "Table en plus dans la base Comparée", "", $vData[0])
		EndIf
	Next
	If Not $bPbGen Then RapportAjouterLigne(False, "", "Pas de Table en plus dans la base Comparée")
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction ajoutant un ligne au rapport (tableau $sRapport[][])
;
; IN  $bErreur : True si la ligne est une erreur, False si la ligne est uine information
;	  $sCol1   : Table en cours
;	  $sCol2   : L'information traitée
;	  $sCol3   : Valeur dans la Base de Référence
;	  $sCol4   : Valeur dans la Base Comparée
; OUT $sRapport[][] est mis à jour et $NbLigneRapport est incrémenté
;--------------------------------------------------------------------------------------------------------------------------------
Func RapportAjouterLigne($bErreur, $sCol1, $sCol2, $sCol3 = "", $sCol4 = "", $iSpecial = 0)
	$NbLigneRapport += 1
	ReDim $sRapport[$NbLigneRapport][5]
	If $bErreur Then
		$sRapport[$NbLigneRapport - 1][0] = "X"
	Else
		$sRapport[$NbLigneRapport - 1][0] = ""
	EndIf
	$sRapport[$NbLigneRapport - 1][1] = $sCol1
	$sRapport[$NbLigneRapport - 1][2] = $sCol2
	$sRapport[$NbLigneRapport - 1][3] = $sCol3
	$sRapport[$NbLigneRapport - 1][4] = $sCol4
	Switch $iSpecial
		Case 1
			$sRapport[$NbLigneRapport - 1][0] = "----------------------"
		Case 2
			$sRapport[$NbLigneRapport - 1][0] = "Erreur"
	EndSwitch
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction activée sur l'appui de la touche Suivante
;
; IN  $iEtape
; OUT $iEtape mis à jour
;--------------------------------------------------------------------------------------------------------------------------------
Func AvanceEtape()
	Local $s
	If $iEtape = 0 Then
		; Ouverture des 2 bases et charges les 2 schémas
		$sBaseRef = GUICtrlRead($InputBaseRef)
		If Not OuvertureDb($sBaseRef, "de référence", $hBaseRef, $sListeTableBaseRef) then Return False
		$sBaseComp = GUICtrlRead($InputBaseComp)
		If Not OuvertureDb($sBaseComp, "à comparer", $hBaseComp, $sListeTableBaseComp) then Return False
		If $sBaseRef = $sBaseComp Then
			MsgBox(4112, "Erreur", "Vous devez choisir 2 bases différentes", 0, $FormCompSQLite)
			Return False
		EndIf
		; Initilisation de compteurs
		$NbLigneRapport = 0
		; Rapport
		RapportAjouterLigne(False, "Analyse de 2 bases Sqlite", @MDAY & "-" & @MON & "-" & @YEAR & " " & @HOUR & ":" & @MIN)
		RapportAjouterLigne(False, "Base de Référence", $sBaseRef, "integrity_check OK")
		RapportAjouterLigne(False, "Base Comparée", $sBaseComp, "integrity_check OK")
		RapportAjouterLigne(False, "----------------------", "----------------------", "----------------------", "----------------------", 1)
		RapportAjouterLigne(False, "Table", "Analyse", "Valeur de la Base de Référence", "Valeur de la Base Comparée", 2)
		RapportAjouterLigne(False, "----------------------", "----------------------", "----------------------", "----------------------", 1)
		; MAJ Fichier INI
		EcrireIni("DB", "DB-Ref", GUICtrlRead($InputBaseRef))
		EcrireIni("DB", "DB-Comp", GUICtrlRead($InputBaseComp))
	EndIf
	If $iEtape > 0 Then EcrireIni("Table", "Etape" & $iEtape, $sListeTableBaseRef[$iEtape] & ":" & ConnaitreChoixAnalyse())
	If $iEtape <= $sListeTableBaseRef[0] Then
		If $iEtape > 0 Then Analyse($iEtape)
		If $iEtape = $sListeTableBaseRef[0] Then
			AnalyseTableEnPlusBaseComp()
			ModeEtape0()
			_ArrayDisplay($sRapport, "Rapport d'analyse")
			; => la syntaxe ci-dessous ne donne que des lignes blanches dans certains cas (détail des enregistrements)
			; _ArrayDisplay($sRapport, "Rapport d'analyse", -1, 0, "", "|", "N°|Erreur|Table|Analyse|Valeur de la Base de Référence|Valeur de la Base Comparée")
		Else
			ModeEtapeAutre()
			$s = LireIni("Table", "Etape" & $iEtape, Chr(1))
			If StringInStr($s, $sListeTableBaseRef[$iEtape] & ":") = 1 Then
				$s = StringMid($s, StringLen($sListeTableBaseRef[$iEtape] & ":") + 1)
				MettreChoixAnalyse($s)
			EndIf
		EndIf
	EndIf
	Return True
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction appelée au retour de l'étape 0
;
; IN  $iEtape
; OUT $iEtape mis à jour
;--------------------------------------------------------------------------------------------------------------------------------
Func ModeEtape0()
	GUICtrlSetData($InputTableRef, "")
	$iEtape = 0
	GUICtrlSetState($InputBaseRef, $GUI_ENABLE)
	GUICtrlSetState($ButtonChercheBaseRef, $GUI_ENABLE)
	GUICtrlSetState($ButtonSwap, $GUI_ENABLE)
	GUICtrlSetState($InputBaseComp, $GUI_ENABLE)
	GUICtrlSetState($ButtonChercheBaseComp, $GUI_ENABLE)
	GUICtrlSetState($LabelTableRef, $GUI_DISABLE)
	GUICtrlSetState($ButtonEtapeUne, $GUI_DISABLE)
	GUICtrlSetState($ButtonSuiv, $GUI_ENABLE)
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction appelée aux étapes différentes de l'étape 0
;
; IN  $iEtape
; OUT $iEtape mis à jour
;--------------------------------------------------------------------------------------------------------------------------------
Func ModeEtapeAutre()
	$iEtape += 1
	GUICtrlSetData($InputTableRef, $sListeTableBaseRef[$iEtape])
	GUICtrlSetState($InputBaseRef, $GUI_DISABLE)
	GUICtrlSetState($ButtonChercheBaseRef, $GUI_DISABLE)
	GUICtrlSetState($ButtonSwap, $GUI_DISABLE)
	GUICtrlSetState($InputBaseComp, $GUI_DISABLE)
	GUICtrlSetState($ButtonChercheBaseComp, $GUI_DISABLE)
	GUICtrlSetState($LabelTableRef, $GUI_ENABLE)
	GUICtrlSetState($ButtonEtapeUne, $GUI_ENABLE)
	If $iEtape > $sListeTableBaseRef[0] Then
		GUICtrlSetState($ButtonSuiv, $GUI_DISABLE)
	Else
		GUICtrlSetState($ButtonSuiv, $GUI_ENABLE)
	EndIf
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Ouverture des Bases
;
; IN  $sDb		   : Nom complet de la base à ouvrir (Chemin + nom complet)
;	  $sTitre	   : Titre de la base (Référence ou Comparée)
; OUT $hDb		   : ID de la base ouverte
;	  $sListeTable : Liste des tables (hors sqlite_...) : $sListeTable[0]=Nombre de tables, $sListeTable[1]=Première table, $sListeTable[2]=Deuxième table, ...
;	  Retourne True si ouverture réussie, False sinon
;--------------------------------------------------------------------------------------------------------------------------------
Func OuvertureDb($sDb, $sTitre, ByRef $hDb, ByRef $sListeTable)
	Local $vData, $hQuery, $i
	;
	If $sDb = "" Then
		MsgBox(4112, "Erreur", "Saisissez le nom de la base " & $sTitre, 0, $FormCompSQLite)
		Return False
	EndIf
	If Not FileExists($sDb) Then
		MsgBox(4112, "Erreur", "La base " & $sTitre & " n'existe pas", 0, $FormCompSQLite)
		Return False
	EndIf
	$hDb = _SQLite_Open($sDb)
	If @error > 0 Then
		MsgBox(4112, "Erreur", "La base " & $sTitre & " ne peut être chargée !", 0, $FormCompSQLite)
		Return False
	EndIf
	; Check de la base
	If Not CheckIntegrity($hDb, $sTitre) Then
		_SQLite_Close($hDb)
		Return False
	EndIf
	; Struture de la table sqlite_master : type TEXT, name TEXT, tbl_name TEXT, rootpage INTEGER, sql TEXT
	; Vérif de structure de la table sqlite_master
	If _SQLite_QuerySingleRow($hDB, "SELECT type, name, tbl_name, sql FROM sqlite_master", $vData) <> $SQLITE_OK Then
		_SQLite_Close($hDb)
		MsgBox(4112, "Erreur", "La struture de la table système 'sqlite_master' n'est pas correcte" & @CRLF & "l'un des champs (typed, name, tbl_name, sql) n'est pas trouvé", 0, $FormCompSQLite)
		Return False
	EndIf
	; Liste des tables
	$sListeTable[0] = 0
	_SQlite_Query($hDB, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name ASC;", $hQuery)
	While _SQLite_FetchData($hQuery, $vData) = $SQLITE_OK
		If StringLeft($vData[0], 7) <> "sqlite_" Then
			$sListeTable[0] += 1
			ReDim $sListeTable[$sListeTable[0] + 1]
			$sListeTable[$sListeTable[0]] = $vData[0]
		EndIf
	WEnd
	_SQLite_QueryFinalize($hQuery)
	;
	Return True
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction procédant au check de l'intégrité du base SQLite ouverte
;
; IN  $hDb : ID de la base ouverte
; OUT True si OK, False sinon
;--------------------------------------------------------------------------------------------------------------------------------
Func CheckIntegrity($hDb, $sTitre)
	Local $sData
	If _SQLite_QuerySingleRow($hDb, "PRAGMA integrity_check;", $sData) = $SQLITE_OK Then
		If StringUpper($sData[0]) = "OK" Then
			Return True
		Else
			MsgBox(4112, "Erreur", "Votre base " & $sTitre & " n'est pas intégre (integrity_check retour une ereur) !", 0, $FormCompSQLite)
			Return False
		EndIf
	Else
		MsgBox(4112, "Erreur", "Votre base " & $sTitre & " n'est pas intégre (integrity_check a échoué) !", 0, $FormCompSQLite)
		Return False
	EndIf
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction retournant un nom de table ou de champ encadré de []
;
; IN  $Nom : le nom d'une table ou d'un champ
; OUT Le nom encadré de []
;--------------------------------------------------------------------------------------------------------------------------------
Func NomSql($sNom)
	If StringInStr($sNom, "[") = 0 Then
		Return "["& $sNom & "]"
	Else
		Return $sNom
	EndIf
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction remplaçant une quote (') par une double quote ('') dans les valeurs (utilisé pour les clause Where principalement)
;
; IN  $Texte : Le texte à transformer
; OUT Le Texte transformé
;--------------------------------------------------------------------------------------------------------------------------------
Func Quote($sTexte)
	Return StringReplace($sTexte, "'", "''")
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Lecture d'une Cle dans le fichier INI
;
; IN  $sSection : Section de la clé
;	  $sCle		: Clé à rechercher
;	  $vDefaut	: Valeur par défaut (si pas clé non trouvée)
; OUT La valeur retournée
;--------------------------------------------------------------------------------------------------------------------------------
Func LireIni($sSection, $sCle, $sDefaut)
	Return IniRead(@ScriptDir & "\" & StringLeft(@ScriptName, StringLen(@ScriptName) - 4) & ".ini", $sSection, $sCle, $sDefaut)
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Ecriture d'une Valeur pour une Cle et une Section dans le fichier INI
;
; IN  $sSection : Section de la clé
;	  $sCle		: Clé à rechercher
;	  $sValeur	: Valeur à écrire
; OUT La valeur retournée
;--------------------------------------------------------------------------------------------------------------------------------
Func EcrireIni($sSection, $sCle, $sValeur)
	Return (IniWrite(@ScriptDir & "\" & StringLeft(@ScriptName, StringLen(@ScriptName) - 4) & ".ini", $sSection, $sCle, $sValeur) = 1)
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction donnant l'indice du tableau de choix d'analyse
;
; IN  /
; OUT Indice (de 0 à ...)
;--------------------------------------------------------------------------------------------------------------------------------
Func ConnaitreChoixAnalyse()
	Local $i, $iChoix = -1
	For $i = 0 To UBound($sListeAnalyse)
		If GUICtrlRead($ComboAnalyse) = $sListeAnalyse[$i] Then
			$iChoix = $i
			ExitLoop
		EndIf
	Next
	Return $iChoix
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction mettant à jour la combo Analyse
;
; IN  $iChoix : Le choix sélectionné (de 0 à ...)
; OUT La Combo est mise à jour
;--------------------------------------------------------------------------------------------------------------------------------
Func MettreChoixAnalyse($iChoix)
	Local $i
	_GUICtrlComboBox_ResetContent($ComboAnalyse)
    _GUICtrlComboBox_BeginUpdate($ComboAnalyse)
	For $i = 0 To UBound($sListeAnalyse) -1
		_GUICtrlComboBox_AddString($ComboAnalyse, $sListeAnalyse[$i])
	Next
    _GUICtrlComboBox_EndUpdate($ComboAnalyse)
	_GUICtrlComboBox_SetCurSel($ComboAnalyse, $iChoix)
EndFunc


;--------------------------------------------------------------------------------------------------------------------------------
; Fonction mettant un non de dossier (ou répertoire)
;
; IN  $sValActuel : Cette valeur peut contenir un nom de fichier en plus d'un répertoire
;	  $sDefaut	  : valeur pas défaut, si la valeur actuelle n'est pas cohérente
; OUT Le nom du dossier résultant
;--------------------------------------------------------------------------------------------------------------------------------
Func DossierParDefaut($sValActuel, $sDefaut)
	Local $sElement, $i, $j, $s, $b = False
	If $sValActuel = "" Then Return $sDefaut
	$sElement = StringSplit($sValActuel, "\")
	For $i = $sElement[0] To 1 Step -1
		$s = $sElement[1]
		For $j = 2 To $i
			$s &= "\" & $sElement[$j]
		Next
		If _RepertoireExistant($s) Then
			$b = True
			ExitLoop
		EndIf
	Next
	If $b Then
		Return $s
	Else
		Return $sDefaut
	EndIf
EndFunc


;--------------------------------------------------------------------------------------------------
; Fonction indiquant si le répertoire existe
;
; IN  $sRepertoire : Nom complet du répertoire (avec ou sans \ en fin)
; OUT True si le répertoire existe, False sinon
;--------------------------------------------------------------------------------------------------
Func _RepertoireExistant($sRepertoire)
	If $sRepertoire = "" Then
		Return False
	EndIf
	If DriveStatus($sRepertoire) = "READY" Then
		Return True
	Else
		Return False
	EndIf
EndFunc