├── README.md ├── SQLiteRecover.sln ├── SQLiteRecover.v11.suo ├── SQLiteRecover.v12.suo └── SQLiteRecover ├── CppSQLite3U.cpp ├── CppSQLite3U.h ├── PageRecover.cpp ├── ReadMe.txt ├── RecordCarving.cpp ├── Resource.h ├── SQLiteCreator.cpp ├── SQLiteCreator.h ├── SQLiteDTO.h ├── SQLiteExtractor.cpp ├── SQLiteExtractor.h ├── SQLiteJournalRecover.cpp ├── SQLiteJournalRecover.h ├── SQLiteReader.cpp ├── SQLiteReader.h ├── SQLiteRecover.cpp ├── SQLiteRecover.h ├── SQLiteRecover.rc ├── SQLiteRecover.vcxproj ├── SQLiteRecover.vcxproj.filters ├── SQLiteRecover.vcxproj.user ├── SQLiteRecovery.cpp ├── SQLiteRecovery.h ├── SQLiteWALDTO.h ├── SQLiteWALRecover.cpp ├── SQLiteWALRecover.h ├── SchemaPackage.cpp ├── UTF8Checker.cpp ├── UTF8Checker.h ├── UTIL.cpp ├── UTIL.h ├── page ├── sqlite3.dll ├── sqlite3.h ├── sqlite3.lib ├── stdafx.cpp ├── stdafx.h └── targetver.h /README.md: -------------------------------------------------------------------------------- 1 | # SQLiteRecover -------------------------------------------------------------------------------- /SQLiteRecover.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2013 4 | VisualStudioVersion = 12.0.21005.1 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SQLiteRecover", "SQLiteRecover\SQLiteRecover.vcxproj", "{1E143C19-C012-45C6-961C-43E6B0B01D5A}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|Win32 = Debug|Win32 11 | Release|Win32 = Release|Win32 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {1E143C19-C012-45C6-961C-43E6B0B01D5A}.Debug|Win32.ActiveCfg = Debug|Win32 15 | {1E143C19-C012-45C6-961C-43E6B0B01D5A}.Debug|Win32.Build.0 = Debug|Win32 16 | {1E143C19-C012-45C6-961C-43E6B0B01D5A}.Release|Win32.ActiveCfg = Release|Win32 17 | {1E143C19-C012-45C6-961C-43E6B0B01D5A}.Release|Win32.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /SQLiteRecover.v11.suo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover.v11.suo -------------------------------------------------------------------------------- /SQLiteRecover.v12.suo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover.v12.suo -------------------------------------------------------------------------------- /SQLiteRecover/CppSQLite3U.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/CppSQLite3U.cpp -------------------------------------------------------------------------------- /SQLiteRecover/CppSQLite3U.h: -------------------------------------------------------------------------------- 1 | //////////////////////////////////////////////////////////////////////////////// 2 | // CppSQLite3U is a C++ unicode wrapper around the SQLite3 embedded database library. 3 | // 4 | // Copyright (c) 2006 Tyushkov Nikolay. All Rights Reserved. http://softvoile.com 5 | // 6 | // 7 | // Based on beautiful wrapper written by Rob Groves 8 | // (https://secure.codeproject.com/database/CppSQLite.asp). 9 | // Very good wrapper, but without unicode support unfortunately. 10 | // So, I have reconstructed it for unicode. 11 | // 12 | // CppSQLite3 wrapper: 13 | // Copyright (c) 2004 Rob Groves. All Rights Reserved. rob.groves@btinternet.com 14 | // 15 | // Permission to use, copy, modify, and distribute this software and its 16 | // documentation for any purpose, without fee, and without a written 17 | // agreement, is hereby granted, provided that the above copyright notice, 18 | // this paragraph and the following two paragraphs appear in all copies, 19 | // modifications, and distributions. 20 | // 21 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, 22 | // INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST 23 | // PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, 24 | // EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 | // 26 | // THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT 27 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 28 | // PARTICULAR PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF 29 | // ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". THE AUTHOR HAS NO OBLIGATION 30 | // TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 31 | // 32 | // If you want to get some documentation look at 33 | // https://secure.codeproject.com/database/CppSQLite.asp 34 | // Note, not all features from CppSQLite3 were implemented in CppSQLite3U 35 | // 36 | // V1.0 11/06/2006 - Initial Public Version 37 | // 38 | // Noteses : 39 | // I have tested this wrapper only in unicode version, so I have no idea 40 | // about its work in ANSI configuration, I think it doesn't work without modification;) 41 | // 42 | // Home page : http://softvoile.com/development/CppSQLite3U/ 43 | // Please send all bug report and comment to mail2@softvoile.com 44 | // 45 | // 46 | //////////////////////////////////////////////////////////////////////////////// 47 | 48 | #if !defined(AFX_CPPSQLITE3U_H__1B1BE273_2D1E_439C_946F_3CBD1C0EFD2F__INCLUDED_) 49 | #define AFX_CPPSQLITE3U_H__1B1BE273_2D1E_439C_946F_3CBD1C0EFD2F__INCLUDED_ 50 | 51 | #if _MSC_VER > 1000 52 | #pragma once 53 | #endif // _MSC_VER > 1000 54 | // CppSQLite3U.h : header file 55 | // 56 | #include "sqlite3.h" 57 | #include "atlstr.h" 58 | ///////////////////////////////////////////////////////////////////////////// 59 | 60 | #define SQL_MAXSIZE 2048 61 | 62 | #define CPPSQLITE_ERROR 1000 63 | static const bool DONT_DELETE_MSG=false; 64 | 65 | 66 | CString DoubleQuotes(CString in); 67 | 68 | class CppSQLite3Query; 69 | class CppSQLite3Statement; 70 | 71 | 72 | class CppSQLite3Table 73 | { 74 | public: 75 | 76 | CppSQLite3Table(); 77 | 78 | CppSQLite3Table(const CppSQLite3Table& rTable); 79 | 80 | CppSQLite3Table(char** paszResults, int nRows, int nCols); 81 | 82 | UINT64 GetRowCount(); 83 | 84 | 85 | 86 | virtual ~CppSQLite3Table(); 87 | 88 | CppSQLite3Table& operator=(const CppSQLite3Table& rTable); 89 | 90 | int GetColumnCount(); 91 | 92 | // Namheun For Unicode 93 | const WCHAR* GetWCharFieldValue(int nField ); 94 | const WCHAR* GetWCharFieldName(int nCol); 95 | 96 | 97 | 98 | const char* fieldName(int nCol); 99 | 100 | const char* fieldValue(int nField); 101 | const char* fieldValue(const char* szField); 102 | 103 | int getIntField(int nField, int nNullValue=0); 104 | int getIntField(const char* szField, int nNullValue=0); 105 | 106 | double getFloatField(int nField, double fNullValue=0.0); 107 | double getFloatField(const char* szField, double fNullValue=0.0); 108 | 109 | const char* getStringField(int nField, const char* szNullValue=""); 110 | const char* getStringField(const char* szField, const char* szNullValue=""); 111 | 112 | bool fieldIsNull(int nField); 113 | bool fieldIsNull(const char* szField); 114 | 115 | void setRow(int nRow); 116 | 117 | void finalize(); 118 | 119 | 120 | public: 121 | 122 | void checkResults(); 123 | 124 | int mnCols; 125 | UINT64 mnRows; 126 | int mnCurrentRow; 127 | char** mpaszResults; 128 | }; 129 | 130 | 131 | class CppSQLite3Exception 132 | { 133 | public: 134 | 135 | CppSQLite3Exception(const int nErrCode, 136 | LPTSTR szErrMess, 137 | bool bDeleteMsg=true); 138 | 139 | CppSQLite3Exception(const CppSQLite3Exception& e); 140 | 141 | virtual ~CppSQLite3Exception(); 142 | 143 | const int errorCode() { return mnErrCode; } 144 | 145 | LPCTSTR errorMessage() { return mpszErrMess; } 146 | 147 | static LPCTSTR errorCodeAsString(int nErrCode); 148 | 149 | private: 150 | 151 | int mnErrCode; 152 | LPTSTR mpszErrMess; 153 | }; 154 | 155 | 156 | class CppSQLite3DB 157 | { 158 | // Construction 159 | public: 160 | CppSQLite3DB(); 161 | 162 | // Operations 163 | public: 164 | 165 | virtual ~CppSQLite3DB(); 166 | 167 | 168 | void open(LPCTSTR szFile); 169 | 170 | void close(); 171 | bool tableExists(LPCTSTR szTable); 172 | int execDML(LPCTSTR szSQL); 173 | 174 | CppSQLite3Query execQuery(LPCTSTR szSQL); 175 | 176 | int execScalar(LPCTSTR szSQL); 177 | CString execScalarStr(LPCTSTR szSQL); 178 | 179 | CppSQLite3Statement compileStatement(LPCTSTR szSQL); 180 | 181 | sqlite_int64 lastRowId(); 182 | 183 | void interrupt() { sqlite3_interrupt(mpDB); } 184 | 185 | void setBusyTimeout(int nMillisecs); 186 | 187 | static const char* SQLiteVersion() { return SQLITE_VERSION; }; 188 | 189 | CppSQLite3Table getTable(const char* szSQL); 190 | CppSQLite3Table getTable( const WCHAR* szSQL ); 191 | 192 | 193 | BOOL Open_Optimization(CString FileName); 194 | 195 | BOOL AUTOCOMMIT_OFF(); 196 | BOOL COMMIT(); 197 | 198 | 199 | 200 | public: 201 | 202 | CppSQLite3DB(const CppSQLite3DB& db); 203 | CppSQLite3DB& operator=(const CppSQLite3DB& db); 204 | 205 | sqlite3_stmt* compile(LPCTSTR szSQL); 206 | 207 | void checkDB(); 208 | public: 209 | sqlite3* mpDB; 210 | int mnBusyTimeoutMs; 211 | }; 212 | ///////////////////////////////////////////////////////////////////////////// 213 | 214 | class CppSQLite3Statement 215 | { 216 | public: 217 | 218 | CppSQLite3Statement(); 219 | 220 | CppSQLite3Statement(const CppSQLite3Statement& rStatement); 221 | 222 | CppSQLite3Statement(sqlite3* pDB, sqlite3_stmt* pVM); 223 | 224 | virtual ~CppSQLite3Statement(); 225 | 226 | CppSQLite3Statement& operator=(const CppSQLite3Statement& rStatement); 227 | 228 | int execDML(); 229 | 230 | CppSQLite3Query execQuery(); 231 | 232 | void bind(int nParam, LPCTSTR szValue); 233 | void bind(int nParam, const int nValue); 234 | void bind(int nParam, const double dwValue); 235 | void bind(int nParam, const unsigned char* blobValue, int nLen); 236 | void bindNull(int nParam); 237 | 238 | void reset(); 239 | 240 | void finalize(); 241 | 242 | private: 243 | 244 | void checkDB(); 245 | void checkVM(); 246 | 247 | sqlite3* mpDB; 248 | sqlite3_stmt* mpVM; 249 | }; 250 | ///////////////////// CppSQLite3Query ////////////////////////////////////////////////// 251 | class CppSQLite3Query 252 | { 253 | public: 254 | 255 | CppSQLite3Query(); 256 | 257 | CppSQLite3Query(const CppSQLite3Query& rQuery); 258 | 259 | CppSQLite3Query(sqlite3* pDB, 260 | sqlite3_stmt* pVM, 261 | bool bEof, 262 | bool bOwnVM=true); 263 | 264 | CppSQLite3Query& operator=(const CppSQLite3Query& rQuery); 265 | 266 | virtual ~CppSQLite3Query(); 267 | 268 | int numFields(); 269 | int numCols(); 270 | 271 | 272 | int fieldIndex(LPCTSTR szField); 273 | LPCTSTR fieldName(int nCol); 274 | 275 | LPCTSTR fieldDeclType(int nCol); 276 | int fieldDataType(int nCol); 277 | 278 | LPCTSTR fieldValue(int nField); 279 | LPCTSTR fieldValue(LPCTSTR szField); 280 | 281 | int fieldValueInt(int nField); 282 | int fieldValueInt(LPCTSTR szField); 283 | 284 | int getIntField(int nField, int nNullValue=0); 285 | int getIntField(LPCTSTR szField, int nNullValue=0); 286 | 287 | double getFloatField(int nField, double fNullValue=0.0); 288 | double getFloatField(LPCTSTR szField, double fNullValue=0.0); 289 | 290 | LPCTSTR getStringField(int nField, LPCTSTR szNullValue=_T("")); 291 | LPCTSTR getStringField(LPCTSTR szField, LPCTSTR szNullValue=_T("")); 292 | 293 | const unsigned char* getBlobField(int nField, int& nLen); 294 | const unsigned char* getBlobField(LPCTSTR szField, int& nLen); 295 | 296 | bool fieldIsNull(int nField); 297 | bool fieldIsNull(LPCTSTR szField); 298 | 299 | bool eof(); 300 | void nextRow(); 301 | void finalize(); 302 | 303 | private: 304 | 305 | void checkVM(); 306 | 307 | sqlite3* mpDB; 308 | sqlite3_stmt* mpVM; 309 | bool mbEof; 310 | int mnCols; 311 | bool mbOwnVM; 312 | }; 313 | 314 | 315 | 316 | ///////////////////////////////////////////////////////////////////////////// 317 | // 318 | // TCHAR based sqlite3 function names for Unicode/MCBS builds. 319 | // 320 | #if defined(_UNICODE) || defined(UNICODE) 321 | #pragma message("Unicode Selected") 322 | #define _sqlite3_aggregate_context sqlite3_aggregate_context 323 | #define _sqlite3_aggregate_count sqlite3_aggregate_count 324 | #define _sqlite3_bind_blob sqlite3_bind_blob 325 | #define _sqlite3_bind_double sqlite3_bind_double 326 | #define _sqlite3_bind_int sqlite3_bind_int 327 | #define _sqlite3_bind_int64 sqlite3_bind_int64 328 | #define _sqlite3_bind_null sqlite3_bind_null 329 | #define _sqlite3_bind_parameter_count sqlite3_bind_parameter_count 330 | #define _sqlite3_bind_parameter_index sqlite3_bind_parameter_index 331 | #define _sqlite3_bind_parameter_name sqlite3_bind_parameter_name 332 | #define _sqlite3_bind_text sqlite3_bind_text16 333 | #define _sqlite3_bind_text16 sqlite3_bind_text16 334 | #define _sqlite3_busy_handler sqlite3_busy_handler 335 | #define _sqlite3_busy_timeout sqlite3_busy_timeout 336 | #define _sqlite3_changes sqlite3_changes 337 | #define _sqlite3_close sqlite3_close 338 | #define _sqlite3_collation_needed sqlite3_collation_needed16 339 | #define _sqlite3_collation_needed16 sqlite3_collation_needed16 340 | #define _sqlite3_column_blob sqlite3_column_blob 341 | #define _sqlite3_column_bytes sqlite3_column_bytes16 342 | #define _sqlite3_column_bytes16 sqlite3_column_bytes16 343 | #define _sqlite3_column_count sqlite3_column_count 344 | #define _sqlite3_column_decltype sqlite3_column_decltype16 345 | #define _sqlite3_column_decltype16 sqlite3_column_decltype16 346 | #define _sqlite3_column_double sqlite3_column_double 347 | #define _sqlite3_column_int sqlite3_column_int 348 | #define _sqlite3_column_int64 sqlite3_column_int64 349 | #define _sqlite3_column_name sqlite3_column_name16 350 | #define _sqlite3_column_name16 sqlite3_column_name16 351 | #define _sqlite3_column_text sqlite3_column_text16 352 | #define _sqlite3_column_text16 sqlite3_column_text16 353 | #define _sqlite3_column_type sqlite3_column_type 354 | #define _sqlite3_commit_hook sqlite3_commit_hook 355 | #define _sqlite3_complete sqlite3_complete16 356 | #define _sqlite3_complete16 sqlite3_complete16 357 | #define _sqlite3_create_collation sqlite3_create_collation16 358 | #define _sqlite3_create_collation16 sqlite3_create_collation16 359 | #define _sqlite3_create_function sqlite3_create_function16 360 | #define _sqlite3_create_function16 sqlite3_create_function16 361 | #define _sqlite3_data_count sqlite3_data_count 362 | #define _sqlite3_errcode sqlite3_errcode 363 | #define _sqlite3_errmsg sqlite3_errmsg16 364 | #define _sqlite3_errmsg16 sqlite3_errmsg16 365 | #define _sqlite3_exec sqlite3_exec 366 | #define _sqlite3_finalize sqlite3_finalize 367 | #define _sqlite3_free sqlite3_free 368 | #define _sqlite3_free_table sqlite3_free_table 369 | #define _sqlite3_get_table sqlite3_get_table 370 | #define _sqlite3_interrupt sqlite3_interrupt 371 | #define _sqlite3_last_insert_rowid sqlite3_last_insert_rowid 372 | #define _sqlite3_libversion sqlite3_libversion 373 | #define _sqlite3_mprintf sqlite3_mprintf 374 | #define _sqlite3_open sqlite3_open16 375 | #define _sqlite3_open16 sqlite3_open16 376 | #define _sqlite3_prepare sqlite3_prepare16 377 | #define _sqlite3_prepare16 sqlite3_prepare16 378 | #define _sqlite3_progress_handler sqlite3_progress_handler 379 | #define _sqlite3_reset sqlite3_reset 380 | #define _sqlite3_result_blob sqlite3_result_blob 381 | #define _sqlite3_result_double sqlite3_result_double 382 | #define _sqlite3_result_error sqlite3_result_error16 383 | #define _sqlite3_result_error16 sqlite3_result_error16 384 | #define _sqlite3_result_int sqlite3_result_int 385 | #define _sqlite3_result_int64 sqlite3_result_int64 386 | #define _sqlite3_result_null sqlite3_result_null 387 | #define _sqlite3_result_text sqlite3_result_text16 388 | #define _sqlite3_result_text16 sqlite3_result_text16 389 | #define _sqlite3_result_text16be sqlite3_result_text16be 390 | #define _sqlite3_result_text16le sqlite3_result_text16le 391 | #define _sqlite3_result_value sqlite3_result_value 392 | #define _sqlite3_set_authorizer sqlite3_set_authorizer 393 | #define _sqlite3_step sqlite3_step 394 | #define _sqlite3_total_changes sqlite3_total_changes 395 | #define _sqlite3_trace sqlite3_trace 396 | #define _sqlite3_user_data sqlite3_user_data 397 | #define _sqlite3_value_blob sqlite3_value_blob 398 | #define _sqlite3_value_bytes sqlite3_value_bytes16 399 | #define _sqlite3_value_bytes16 sqlite3_value_bytes16 400 | #define _sqlite3_value_double sqlite3_value_double 401 | #define _sqlite3_value_int sqlite3_value_int 402 | #define _sqlite3_value_int64 sqlite3_value_int64 403 | #define _sqlite3_value_text sqlite3_value_text16 404 | #define _sqlite3_value_text16 sqlite3_value_text16 405 | #define _sqlite3_value_text16be sqlite3_value_text16be 406 | #define _sqlite3_value_text16le sqlite3_value_text16le 407 | #define _sqlite3_value_type sqlite3_value_type 408 | #define _sqlite3_vmprintf sqlite3_vmprintf 409 | #else 410 | #pragma message("MCBS Selected") 411 | #define _sqlite3_aggregate_context sqlite3_aggregate_context 412 | #define _sqlite3_aggregate_count sqlite3_aggregate_count 413 | #define _sqlite3_bind_blob sqlite3_bind_blob 414 | #define _sqlite3_bind_double sqlite3_bind_double 415 | #define _sqlite3_bind_int sqlite3_bind_int 416 | #define _sqlite3_bind_int64 sqlite3_bind_int64 417 | #define _sqlite3_bind_null sqlite3_bind_null 418 | #define _sqlite3_bind_parameter_count sqlite3_bind_parameter_count 419 | #define _sqlite3_bind_parameter_index sqlite3_bind_parameter_index 420 | #define _sqlite3_bind_parameter_name sqlite3_bind_parameter_name 421 | #define _sqlite3_bind_text sqlite3_bind_text 422 | #define _sqlite3_bind_text16 sqlite3_bind_text16 423 | #define _sqlite3_busy_handler sqlite3_busy_handler 424 | #define _sqlite3_busy_timeout sqlite3_busy_timeout 425 | #define _sqlite3_changes sqlite3_changes 426 | #define _sqlite3_close sqlite3_close 427 | #define _sqlite3_collation_needed sqlite3_collation_needed 428 | #define _sqlite3_collation_needed16 sqlite3_collation_needed16 429 | #define _sqlite3_column_blob sqlite3_column_blob 430 | #define _sqlite3_column_bytes sqlite3_column_bytes 431 | #define _sqlite3_column_bytes16 sqlite3_column_bytes16 432 | #define _sqlite3_column_count sqlite3_column_count 433 | #define _sqlite3_column_decltype sqlite3_column_decltype 434 | #define _sqlite3_column_decltype16 sqlite3_column_decltype16 435 | #define _sqlite3_column_double sqlite3_column_double 436 | #define _sqlite3_column_int sqlite3_column_int 437 | #define _sqlite3_column_int64 sqlite3_column_int64 438 | #define _sqlite3_column_name sqlite3_column_name 439 | #define _sqlite3_column_name16 sqlite3_column_name16 440 | #define _sqlite3_column_text sqlite3_column_text 441 | #define _sqlite3_column_text16 sqlite3_column_text16 442 | #define _sqlite3_column_type sqlite3_column_type 443 | #define _sqlite3_commit_hook sqlite3_commit_hook 444 | #define _sqlite3_complete sqlite3_complete 445 | #define _sqlite3_complete16 sqlite3_complete16 446 | #define _sqlite3_create_collation sqlite3_create_collation 447 | #define _sqlite3_create_collation16 sqlite3_create_collation16 448 | #define _sqlite3_create_function sqlite3_create_function 449 | #define _sqlite3_create_function16 sqlite3_create_function16 450 | #define _sqlite3_data_count sqlite3_data_count 451 | #define _sqlite3_errcode sqlite3_errcode 452 | #define _sqlite3_errmsg sqlite3_errmsg 453 | #define _sqlite3_errmsg16 sqlite3_errmsg16 454 | #define _sqlite3_exec sqlite3_exec 455 | #define _sqlite3_finalize sqlite3_finalize 456 | #define _sqlite3_free sqlite3_free 457 | #define _sqlite3_free_table sqlite3_free_table 458 | #define _sqlite3_get_table sqlite3_get_table 459 | #define _sqlite3_interrupt sqlite3_interrupt 460 | #define _sqlite3_last_insert_rowid sqlite3_last_insert_rowid 461 | #define _sqlite3_libversion sqlite3_libversion 462 | #define _sqlite3_mprintf sqlite3_mprintf 463 | #define _sqlite3_open sqlite3_open 464 | #define _sqlite3_open16 sqlite3_open16 465 | #define _sqlite3_prepare sqlite3_prepare 466 | #define _sqlite3_prepare16 sqlite3_prepare16 467 | #define _sqlite3_progress_handler sqlite3_progress_handler 468 | #define _sqlite3_reset sqlite3_reset 469 | #define _sqlite3_result_blob sqlite3_result_blob 470 | #define _sqlite3_result_double sqlite3_result_double 471 | #define _sqlite3_result_error sqlite3_result_error 472 | #define _sqlite3_result_error16 sqlite3_result_error16 473 | #define _sqlite3_result_int sqlite3_result_int 474 | #define _sqlite3_result_int64 sqlite3_result_int64 475 | #define _sqlite3_result_null sqlite3_result_null 476 | #define _sqlite3_result_text sqlite3_result_text 477 | #define _sqlite3_result_text16 sqlite3_result_text16 478 | #define _sqlite3_result_text16be sqlite3_result_text16be 479 | #define _sqlite3_result_text16le sqlite3_result_text16le 480 | #define _sqlite3_result_value sqlite3_result_value 481 | #define _sqlite3_set_authorizer sqlite3_set_authorizer 482 | #define _sqlite3_step sqlite3_step 483 | #define _sqlite3_total_changes sqlite3_total_changes 484 | #define _sqlite3_trace sqlite3_trace 485 | #define _sqlite3_user_data sqlite3_user_data 486 | #define _sqlite3_value_blob sqlite3_value_blob 487 | #define _sqlite3_value_bytes sqlite3_value_bytes 488 | #define _sqlite3_value_bytes16 sqlite3_value_bytes16 489 | #define _sqlite3_value_double sqlite3_value_double 490 | #define _sqlite3_value_int sqlite3_value_int 491 | #define _sqlite3_value_int64 sqlite3_value_int64 492 | #define _sqlite3_value_text sqlite3_value_text 493 | #define _sqlite3_value_text16 sqlite3_value_text16 494 | #define _sqlite3_value_text16be sqlite3_value_text16be 495 | #define _sqlite3_value_text16le sqlite3_value_text16le 496 | #define _sqlite3_value_type sqlite3_value_type 497 | #define _sqlite3_vmprintf sqlite3_vmprintf 498 | #endif 499 | 500 | //{{AFX_INSERT_LOCATION}} 501 | // Microsoft Visual C++ will insert additional declarations immediately before the previous line. 502 | 503 | #endif // !defined(AFX_CPPSQLITE3U_H__1B1BE273_2D1E_439C_946F_3CBD1C0EFD2F__INCLUDED_) 504 | -------------------------------------------------------------------------------- /SQLiteRecover/PageRecover.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/PageRecover.cpp -------------------------------------------------------------------------------- /SQLiteRecover/ReadMe.txt: -------------------------------------------------------------------------------- 1 | init 2 | -------------------------------------------------------------------------------- /SQLiteRecover/RecordCarving.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/RecordCarving.cpp -------------------------------------------------------------------------------- /SQLiteRecover/Resource.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/Resource.h -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteCreator.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteCreator.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteCreator.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteCreator.h -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteDTO.h: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include 3 | #ifndef __SQLITEDTO_H__ 4 | #define __SQLITEDTO_H__ 5 | 6 | 7 | #define USES_CONVERSION int _convert = 0; (_convert); UINT _acp = ATL::_AtlGetConversionACP() /*CP_THREAD_ACP*/; (_acp); LPCWSTR _lpw = NULL; (_lpw); LPCSTR _lpa = NULL; (_lpa) 8 | 9 | #define INTERNAL_PAGE 0x05 10 | #define LEAF_PAGE 0x0D 11 | #define INTERNAL_PAGE_HEADER_SIZE 0x0C 12 | #define LEAF_PAGE_HEADER_SIZE 0x08 13 | 14 | #define NUMBER_OF_CELL_OFFSET 0x03 15 | #define NUMBER_OF_CELL_OFFSET_SIZE 2 16 | 17 | 18 | #define SCHEMA_PAGE_START 0x64 19 | #define NUMBER_OF_SQLITE_MASTER_SCHEMA 5 20 | #define NUMBER_OF_CELL_OFFSET 0x03 21 | #define NUMBER_OF_CELL_OFFSET_SIZE 2 22 | 23 | 24 | struct SQLITE_COLUMN{ 25 | CString Type; 26 | CString c_id; 27 | CString ColumnName; 28 | INT ColumnLength; 29 | }; 30 | 31 | struct COLUMN 32 | { 33 | INT Length; 34 | INT CLength; 35 | BYTE* Data; 36 | 37 | BOOL isDamaged; 38 | }; 39 | struct FreeBlock{ 40 | INT ColumnInfoStartOffset; 41 | INT DataAreaStartOffset; 42 | COLUMN* columnInfo; 43 | }; 44 | struct Rows{ 45 | INT PageNumber; 46 | __int64 RecordOffset; 47 | std::vector columns; 48 | 49 | }; 50 | 51 | 52 | struct SQLitePage{ 53 | INT PageNumber; 54 | BYTE* Page; 55 | }; 56 | 57 | struct SQLITE_TABLE{ 58 | 59 | CString TableName; 60 | INT RootPageNum; 61 | 62 | std::vector LeafPageNum; //leaf page 63 | std::vector InternalNum; 64 | 65 | INT NumberOfField; 66 | SQLITE_COLUMN* Column; 67 | 68 | std::vector DeletedRecord; 69 | //171024 70 | std::vector NormalRecord; 71 | }; 72 | 73 | 74 | #endif -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteExtractor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteExtractor.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteExtractor.h: -------------------------------------------------------------------------------- 1 | 2 | #include "stdafx.h" 3 | #include "CppSQLite3U.h" 4 | #include "SQLiteDTO.h" 5 | #include 6 | #include 7 | #include 8 | 9 | // enum SQLITIECOPYERR { SOURCE_DB_ERROR, DESTINATION_DB_ERROR, QUERY_ERROR, ANALYZE_SUCCESS, FORENSIC_DB_ERROR, SELECTQUERY_ERROR, PLIST_ERROR }; 10 | 11 | class SQLiteExtractor 12 | { 13 | private : 14 | 15 | /* 16 | File information 17 | */ 18 | CppSQLite3DB m_srcDB; // Specify the SQLite database File 19 | CString m_strFilePath; // SQLite database file path 20 | unsigned __int64 m_nFileSize; // SQLite database file size 21 | 22 | 23 | ///* 24 | // Page information 25 | //*/ 26 | //unsigned __int64 m_nPageStartOffset; // Current page start offset 27 | //unsigned __int64 m_nPageEndOffset; // Current page end offset 28 | // 29 | ///* 30 | // Page Header information 31 | //*/ 32 | // 33 | 34 | unsigned __int64 m_nCurrentOffset; // Current offset 35 | 36 | public : 37 | SQLiteExtractor(); 38 | SQLiteExtractor( CString strFilePath ); 39 | 40 | ~SQLiteExtractor(); 41 | 42 | int Init(); // initialization 43 | BOOL Open(); // SQLite database file open : Compare signature, Check page size 44 | std::vector SchemaTblParsing(); // Schema table parsing : Send query ("SELECT * FROM sqlite_master;") -> Get the information of table count, root page, page field ... 45 | 46 | BOOL Close(); 47 | }; -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteJournalRecover.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteJournalRecover.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteJournalRecover.h: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "UTIL.h" 3 | #include 4 | #include 5 | #ifndef __SQLITEJOURNALRECOVER_H__ 6 | #define __SQLITEJOURNALRECOVER_H__ 7 | 8 | #define START_OF_JOURNAL_PAGE 0x200 9 | #define JOURNAL_PAGE_NUMBER_SIZE 4 10 | #define JOURNAL_PAGE_CHECKSUM_SIZE 4 11 | 12 | struct JournalFrame 13 | { 14 | BYTE PageNumber[4]; 15 | BYTE *Page; 16 | BYTE CheckSum[4]; 17 | }; 18 | 19 | class SQLiteJournal{ 20 | 21 | private: 22 | UTIL ut; 23 | INT PageSize; 24 | std::map> journal; 25 | 26 | public: 27 | 28 | SQLiteJournal(INT _PageSize); 29 | std::map> GetJournalFrameList(); 30 | 31 | BOOL SetJournalFrameList(TCHAR* pszfilename); 32 | 33 | }; 34 | 35 | #endif -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteReader.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteReader.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteReader.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteReader.h -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteRecover.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "resource.h" 4 | 5 | #define VERSION "0.9.29" 6 | #define VERSION2 "1.0(including WAL file)" -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteRecover.rc -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.vcxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {1E143C19-C012-45C6-961C-43E6B0B01D5A} 15 | Win32Proj 16 | SQLiteRecover 17 | 10.0.17134.0 18 | 19 | 20 | 21 | Application 22 | true 23 | Unicode 24 | Static 25 | v141 26 | 27 | 28 | Application 29 | false 30 | v141 31 | true 32 | Unicode 33 | Static 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | true 47 | 48 | 49 | false 50 | $(ProjectDir);$(IncludePath) 51 | $(ProjectDir);$(LibraryPath) 52 | 53 | 54 | 55 | Use 56 | Level3 57 | Disabled 58 | WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) 59 | 60 | 61 | Console 62 | true 63 | sqlite3.lib 64 | 65 | 66 | 67 | 68 | Level3 69 | Use 70 | MaxSpeed 71 | true 72 | true 73 | WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions) 74 | 75 | 76 | Console 77 | true 78 | true 79 | true 80 | sqlite3.lib 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | Create 118 | Create 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | {87200eb9-236f-42c7-aa0b-98addd6ab4b7} 18 | 19 | 20 | {a42aed80-3cb2-4350-b87d-6a55555e0cfd} 21 | 22 | 23 | {01aa4bad-d63a-4ac7-af1b-463842d8cddc} 24 | 25 | 26 | {9ea03979-f48f-48b8-945d-f8a3c903a17c} 27 | 28 | 29 | {fb6dd313-28e4-4682-8e03-b68b2612c0f1} 30 | 31 | 32 | {4435ab2f-ee5b-4a96-9dcc-01f7af986c5c} 33 | 34 | 35 | {764185f3-785a-4a54-bb0b-d99675e50c71} 36 | 37 | 38 | {fa12c6d2-8fe0-4098-a47e-fa712ef2addc} 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 헤더 파일 47 | 48 | 49 | 헤더 파일 50 | 51 | 52 | 헤더 파일 53 | 54 | 55 | 헤더 파일 56 | 57 | 58 | 0x02. Carver 59 | 60 | 61 | 0x00. UTIL 62 | 63 | 64 | 0x00. UTIL\0x01. SQLite UTIL 65 | 66 | 67 | 0x00. UTIL\0x01. SQLite UTIL 68 | 69 | 70 | 0x00. UTIL\0x01. SQLite UTIL 71 | 72 | 73 | 0x01. DATA 74 | 75 | 76 | 0x00. UTIL\0x01. SQLite UTIL 77 | 78 | 79 | 0x03. WAL 80 | 81 | 82 | 0x03. WAL 83 | 84 | 85 | 0x00. UTIL\0x02. UTF8Checker 86 | 87 | 88 | 0x02. Carver 89 | 90 | 91 | 0x04. JOURNAL 92 | 93 | 94 | 95 | 96 | 소스 파일 97 | 98 | 99 | 소스 파일 100 | 101 | 102 | 0x00. UTIL 103 | 104 | 105 | 0x00. UTIL\0x01. SQLite UTIL 106 | 107 | 108 | 0x00. UTIL\0x01. SQLite UTIL 109 | 110 | 111 | 0x00. UTIL\0x01. SQLite UTIL 112 | 113 | 114 | 0x03. WAL 115 | 116 | 117 | 0x02. Carver 118 | 119 | 120 | 0x00. UTIL\0x02. UTF8Checker 121 | 122 | 123 | 0x02. Carver 124 | 125 | 126 | 0x02. Carver 127 | 128 | 129 | 0x04. JOURNAL 130 | 131 | 132 | 0x05. Schema Package 133 | 134 | 135 | 0x02. Carver 136 | 137 | 138 | 139 | 140 | 리소스 파일 141 | 142 | 143 | -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecover.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | "D:\00. DFRC\SQLite\[정리]SQLiteRecover\SQLiteRecover(SchemaParsing)\Debug\KakaoTalk.db" "D:\00. DFRC\SQLite\[정리]SQLiteRecover\SQLiteRecover(SchemaParsing)\Debug\KakaoTalk.db-journal" "D:\00. DFRC\SQLite\[정리]SQLiteRecover\SQLiteRecover(SchemaParsing)\Debug\result" 5 | WindowsLocalDebugger 6 | 7 | 8 | "D:\00. DFRC\SQLite\db샘플\mmssms.db" "." "D:\00. DFRC\SQLite\db샘플" 9 | WindowsLocalDebugger 10 | 11 | -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecovery.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteRecovery.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteRecovery.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteRecovery.h -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteWALDTO.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteWALDTO.h -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteWALRecover.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/SQLiteWALRecover.cpp -------------------------------------------------------------------------------- /SQLiteRecover/SQLiteWALRecover.h: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "SQLiteWALDTO.h" 3 | #include "SQLiteDTO.h" 4 | #include 5 | #include 6 | #include 7 | #include "UTIL.h" 8 | #ifndef __SQLITEWALRECOVER_H__ 9 | #define __SQLITEWALRECOVER_H__ 10 | 11 | class SQLiteWALRecover 12 | { 13 | 14 | public: 15 | 16 | std::map> GetWALFrameList(); 17 | 18 | BOOL SetWALFrameList(TCHAR* pszfilename); 19 | 20 | private: 21 | 22 | 23 | SQLiteWALHeader GetWALHeader(BYTE* buffer); 24 | mWALFrameHeader GetmWALFrameHeader(BYTE* buffer); 25 | WALFrame GetWALFrame(BYTE* buffer, INT PageSize); 26 | 27 | UTIL ut; 28 | 29 | std::map> walmap; 30 | 31 | 32 | }; 33 | 34 | #endif -------------------------------------------------------------------------------- /SQLiteRecover/SchemaPackage.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "SQLiteRecovery.h" 3 | 4 | 5 | VOID SQLiteRecovery::InitSQLiteMasterTable(){ 6 | 7 | sqlite_master.Column = new SQLITE_COLUMN[NUMBER_OF_SQLITE_MASTER_SCHEMA]; 8 | 9 | sqlite_master.Column[0].Type = _T("TEXT"); 10 | sqlite_master.Column[0].ColumnName = L"type"; 11 | sqlite_master.Column[1].Type = _T("TEXT"); 12 | sqlite_master.Column[1].ColumnName = L"name"; 13 | sqlite_master.Column[2].Type = _T("TEXT"); 14 | sqlite_master.Column[2].ColumnName = L"tbl_name"; 15 | sqlite_master.Column[3].Type = _T("INTEGER"); 16 | sqlite_master.Column[3].ColumnName = L"rootpage"; 17 | sqlite_master.Column[4].Type = _T("TEXT"); 18 | sqlite_master.Column[4].ColumnName = L"sql"; 19 | sqlite_master.RootPageNum = 1; 20 | 21 | 22 | 23 | 24 | sqlite_master.TableName = L"sqlite_master"; 25 | sqlite_master.NumberOfField = 5; 26 | 27 | } 28 | 29 | VOID SQLiteRecovery::GetNormalCell(SQLitePage Page, SQLITE_TABLE* table){ 30 | 31 | BYTE Cell[2]; 32 | memcpy(Cell, &Page.Page[NUMBER_OF_CELL_OFFSET], NUMBER_OF_CELL_OFFSET_SIZE); 33 | INT CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 34 | 35 | std::vector celloffset; 36 | std::vector deleted_cell; 37 | 38 | INT StartOffset = LEAF_PAGE_HEADER_SIZE; 39 | 40 | for (int i = 0; i < CellCNT; i++){ 41 | 42 | memcpy(Cell, &Page.Page[StartOffset], NUMBER_OF_CELL_OFFSET_SIZE); 43 | celloffset.push_back(ut.IntToByte(Cell, 2)); 44 | StartOffset += 2; 45 | 46 | } 47 | 48 | // if(Page.PageNumber==0x9b) 49 | // printf("error page here\n"); 50 | 51 | memcpy(Cell, &Page.Page[1], 2); 52 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 53 | 54 | while (CellCNT != 0){ 55 | 56 | celloffset.push_back(ut.IntToByte(Cell, 2)); 57 | deleted_cell.push_back(ut.IntToByte(Cell, 2)); 58 | 59 | memcpy(Cell, &Page.Page[CellCNT], NUMBER_OF_CELL_OFFSET_SIZE); 60 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 61 | 62 | } 63 | 64 | 65 | // printf("%d , error page number\n", Page.PageNumber); 66 | 67 | sort(celloffset.begin(), celloffset.end()); 68 | 69 | /* 70 | 1. 정상레코드는 셀과 셀 사이 간격을 구해 71 | 2. 레코드 총 길이보다 셀과 셀 사이 간격이 더 작을경우 오버플로우 72 | 3. 뒤에 셀오프셋에서 4바이트땅겨서 그거 오버플로우 페이지 판별. 73 | */ 74 | 75 | for (int i = 0; i < celloffset.size(); i++){ 76 | 77 | 78 | StartOffset = celloffset[i]; 79 | INT EndOffset = StartOffset; 80 | INT RecordToRecord = 0; 81 | INT CellSize = 0; 82 | INT HeaderSize = 0; 83 | BOOL isDeleted = FALSE; 84 | 85 | if (i == celloffset.size() - 1) 86 | RecordToRecord = PageSize - celloffset[i] + 2; 87 | else 88 | RecordToRecord = celloffset[i + 1] - celloffset[i]; 89 | 90 | 91 | for (int k = 0; k < deleted_cell.size(); k++){ 92 | 93 | if (celloffset[i] == deleted_cell[k]) 94 | { 95 | isDeleted = TRUE; 96 | } 97 | 98 | } 99 | 100 | if (isDeleted) //deleterecord 101 | { 102 | BYTE FreeBlockSize[3]; 103 | memcpy(FreeBlockSize, &Page.Page[StartOffset + 2], 2); 104 | 105 | // INT EndOffset = StartOffset + ut.IntToByte(FreeBlockSize,2); 106 | CellSize = ut.IntToByte(FreeBlockSize,2); 107 | INT EndOffset = StartOffset + CellSize; 108 | StartOffset += 4; 109 | 110 | StartOffset = GetColumnStartOffset(Page.Page, StartOffset, EndOffset, *table); 111 | 112 | if (StartOffset == -1) 113 | continue; 114 | 115 | BOOL overflow_e = FALSE; 116 | 117 | if (CellSize > RecordToRecord) 118 | { 119 | BYTE PageNumber[4]; 120 | memcpy(PageNumber, &Page.Page[StartOffset + RecordToRecord - 4], 4); 121 | INT OverflowPageNumberStart = ut.LongIntToByte(PageNumber, 4); 122 | 123 | if(OverflowPageNumberStart > FileSize / PageSize) 124 | { 125 | OverflowPageNumberStart = OverflowPageNumberStart >> 16; 126 | overflow_e = TRUE; 127 | 128 | } 129 | CarvingRecordContainOverflow(Page, 130 | OverflowPageNumberStart, 131 | StartOffset, 132 | RecordToRecord - 4, // 레코드 크기. 133 | CellSize, // 전체 셀 사이즈로 하자. 134 | table, 135 | overflow_e); //overflow 페이지 읽어올때 2byte 초과함 136 | 137 | } 138 | else 139 | CarvingRecord(Page, StartOffset, EndOffset, table); 140 | } 141 | //0131 continue; 142 | 143 | else // 0131 normal record 144 | { 145 | for (int k = 0; k < 3; k++){ 146 | 147 | INT SizeOfLengthField = GetAvailableByteByBitPattern(Page.Page, StartOffset, 1); 148 | // HeaderSize += SizeOfLengthField; 149 | 150 | if (k == 0){ 151 | BYTE* SizeOfRecord = new BYTE[SizeOfLengthField + 1]; 152 | memcpy(SizeOfRecord, &Page.Page[StartOffset], SizeOfLengthField); 153 | 154 | CellSize = GetLengthOfBitPattern(SizeOfRecord, SizeOfLengthField); 155 | EndOffset += CellSize; 156 | EndOffset += SizeOfLengthField; 157 | 158 | delete[] SizeOfRecord; 159 | } 160 | HeaderSize += SizeOfLengthField; 161 | StartOffset += SizeOfLengthField; 162 | } 163 | 164 | BOOL overflow_e = FALSE; //대처 165 | 166 | if (CellSize > RecordToRecord) // overflow 167 | { 168 | RecordToRecord -= HeaderSize; 169 | 170 | //대처용 171 | 172 | BYTE PageNumber[4]; 173 | memcpy(PageNumber, &Page.Page[StartOffset + RecordToRecord - 4], 4); 174 | INT OverflowPageNumberStart = ut.LongIntToByte(PageNumber, 4); 175 | 176 | if(OverflowPageNumberStart > FileSize / PageSize) 177 | { 178 | OverflowPageNumberStart = OverflowPageNumberStart >> 16; 179 | overflow_e = TRUE; 180 | 181 | } 182 | ParsingRecordContainOverflow(Page, 183 | OverflowPageNumberStart, 184 | StartOffset, 185 | RecordToRecord - 4, // 레코드 크기. 186 | CellSize, // 전체 셀 사이즈로 하자. 187 | table, 188 | overflow_e); //overflow 페이지 읽어올때 2byte 초과함 189 | } 190 | 191 | else 192 | ParsingRecord(Page, StartOffset, EndOffset, table); 193 | } 194 | } 195 | FreeSpaceAreaCarving(Page, table); 196 | 197 | } 198 | 199 | VOID SQLiteRecovery::GetSchemaCell(SQLitePage Page, SQLITE_TABLE* table){ 200 | 201 | BYTE Cell[2]; 202 | memcpy(Cell, &Page.Page[NUMBER_OF_CELL_OFFSET], NUMBER_OF_CELL_OFFSET_SIZE); 203 | INT CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 204 | 205 | std::vector celloffset; 206 | std::vector deleted_cell; 207 | 208 | INT StartOffset = LEAF_PAGE_HEADER_SIZE; 209 | 210 | for (int i = 0; i < CellCNT; i++){ 211 | 212 | memcpy(Cell, &Page.Page[StartOffset], NUMBER_OF_CELL_OFFSET_SIZE); 213 | celloffset.push_back(ut.IntToByte(Cell, 2)); 214 | StartOffset += 2; 215 | 216 | } 217 | 218 | // if(Page.PageNumber==0x9b) 219 | // printf("error page here\n"); 220 | 221 | memcpy(Cell, &Page.Page[1], 2); 222 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 223 | 224 | while (CellCNT != 0){ 225 | 226 | celloffset.push_back(ut.IntToByte(Cell, 2)); 227 | deleted_cell.push_back(ut.IntToByte(Cell, 2)); 228 | 229 | memcpy(Cell, &Page.Page[CellCNT], NUMBER_OF_CELL_OFFSET_SIZE); 230 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 231 | 232 | } 233 | 234 | 235 | // printf("%d , error page number\n", Page.PageNumber); 236 | 237 | sort(celloffset.begin(), celloffset.end()); 238 | 239 | /* 240 | 1. 정상레코드는 셀과 셀 사이 간격을 구해 241 | 2. 레코드 총 길이보다 셀과 셀 사이 간격이 더 작을경우 오버플로우 242 | 3. 뒤에 셀오프셋에서 4바이트땅겨서 그거 오버플로우 페이지 판별. 243 | */ 244 | 245 | for (int i = 0; i < celloffset.size(); i++){ 246 | 247 | 248 | StartOffset = celloffset[i]; 249 | INT EndOffset = StartOffset; 250 | INT RecordToRecord = 0; 251 | INT CellSize = 0; 252 | INT HeaderSize = 0; 253 | BOOL isDeleted = FALSE; 254 | 255 | if (i == celloffset.size() - 1) 256 | RecordToRecord = PageSize - celloffset[i] + 2; 257 | else 258 | RecordToRecord = celloffset[i + 1] - celloffset[i]; 259 | 260 | 261 | for (int k = 0; k < deleted_cell.size(); k++){ 262 | 263 | if (celloffset[i] == deleted_cell[k]) 264 | { 265 | isDeleted = TRUE; 266 | } 267 | 268 | } 269 | 270 | if (isDeleted) //delete 된 스키마는 고려 x ? 271 | continue; 272 | 273 | for (int k = 0; k < 3; k++){ 274 | 275 | INT SizeOfLengthField = GetAvailableByteByBitPattern(Page.Page, StartOffset, 1); 276 | // HeaderSize += SizeOfLengthField; 277 | 278 | if (k == 0){ 279 | BYTE* SizeOfRecord = new BYTE[SizeOfLengthField + 1]; 280 | memcpy(SizeOfRecord, &Page.Page[StartOffset], SizeOfLengthField); 281 | 282 | CellSize = GetLengthOfBitPattern(SizeOfRecord, SizeOfLengthField); 283 | EndOffset += CellSize; 284 | EndOffset += SizeOfLengthField; 285 | 286 | delete[] SizeOfRecord; 287 | } 288 | HeaderSize += SizeOfLengthField; 289 | StartOffset += SizeOfLengthField; 290 | } 291 | 292 | BOOL overflow_e = FALSE; //대처 293 | 294 | if (CellSize > RecordToRecord) // overflow 295 | { 296 | RecordToRecord -= HeaderSize; 297 | 298 | //대처용 299 | 300 | BYTE PageNumber[4]; 301 | memcpy(PageNumber, &Page.Page[StartOffset + RecordToRecord - 4], 4); 302 | INT OverflowPageNumberStart = ut.LongIntToByte(PageNumber, 4); 303 | 304 | if(OverflowPageNumberStart > FileSize / PageSize) 305 | { 306 | OverflowPageNumberStart = OverflowPageNumberStart >> 16; 307 | overflow_e = TRUE; 308 | 309 | } 310 | ParsingRecordContainOverflow(Page, 311 | OverflowPageNumberStart, 312 | StartOffset, 313 | RecordToRecord - 4, // 레코드 크기. 314 | CellSize, // 전체 셀 사이즈로 하자. 315 | table, 316 | overflow_e); //overflow 페이지 읽어올때 2byte 초과함 317 | } 318 | 319 | else 320 | ParsingRecord(Page, StartOffset, EndOffset, table); 321 | 322 | } 323 | FreeSpaceAreaCarving(Page, table); 324 | 325 | } 326 | 327 | 328 | //171024 329 | VOID SQLiteRecovery::GetSchemaCell_First(SQLitePage Page, SQLITE_TABLE* table){ 330 | 331 | 332 | BYTE Cell[2]; 333 | memcpy(Cell, &Page.Page[NUMBER_OF_CELL_OFFSET+0x64], NUMBER_OF_CELL_OFFSET_SIZE); 334 | INT CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 335 | 336 | std::vector celloffset; 337 | std::vector deleted_cell; 338 | 339 | INT StartOffset = LEAF_PAGE_HEADER_SIZE + 0x64; 340 | 341 | for (int i = 0; i < CellCNT; i++){ 342 | 343 | memcpy(Cell, &Page.Page[StartOffset], NUMBER_OF_CELL_OFFSET_SIZE); 344 | celloffset.push_back(ut.IntToByte(Cell, 2)); 345 | StartOffset += 2; 346 | 347 | } 348 | 349 | memcpy(Cell, &Page.Page[0x65], 2); 350 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 351 | 352 | while (CellCNT != 0){ 353 | 354 | celloffset.push_back(ut.IntToByte(Cell, 2)); 355 | deleted_cell.push_back(ut.IntToByte(Cell, 2)); 356 | 357 | memcpy(Cell, &Page.Page[CellCNT], NUMBER_OF_CELL_OFFSET_SIZE); 358 | CellCNT = ut.LongIntToByte(Cell, NUMBER_OF_CELL_OFFSET_SIZE); 359 | 360 | } 361 | 362 | 363 | sort(celloffset.begin(), celloffset.end()); 364 | 365 | /* 366 | 1. 정상레코드는 셀과 셀 사이 간격을 구해 367 | 2. 레코드 총 길이보다 셀과 셀 사이 간격이 더 작을경우 오버플로우 368 | 3. 뒤에 셀오프셋에서 4바이트땅겨서 그거 오버플로우 페이지 판별. 369 | */ 370 | 371 | for (int i = 0; i < celloffset.size(); i++){ 372 | 373 | 374 | StartOffset = celloffset[i]; 375 | INT EndOffset = StartOffset; 376 | INT RecordToRecord = 0; 377 | INT CellSize = 0; 378 | INT HeaderSize = 0; 379 | BOOL isDeleted = FALSE; 380 | 381 | if (i == celloffset.size() - 1) 382 | RecordToRecord = PageSize - celloffset[i] + 2; 383 | else 384 | RecordToRecord = celloffset[i + 1] - celloffset[i]; 385 | 386 | 387 | for (int k = 0; k < deleted_cell.size(); k++){ 388 | 389 | if (celloffset[i] == deleted_cell[k]) 390 | { 391 | isDeleted = TRUE; 392 | } 393 | 394 | } 395 | 396 | 397 | if (isDeleted) 398 | continue; 399 | 400 | 401 | for (int k = 0; k < 3; k++){ 402 | 403 | INT SizeOfLengthField = GetAvailableByteByBitPattern(Page.Page, StartOffset, 1); 404 | // HeaderSize += SizeOfLengthField; 405 | 406 | if (k == 0){ 407 | BYTE* SizeOfRecord = new BYTE[SizeOfLengthField + 1]; 408 | memcpy(SizeOfRecord, &Page.Page[StartOffset], SizeOfLengthField); 409 | 410 | CellSize = GetLengthOfBitPattern(SizeOfRecord, SizeOfLengthField); 411 | EndOffset += CellSize; 412 | EndOffset += SizeOfLengthField; 413 | 414 | delete[] SizeOfRecord; 415 | } 416 | HeaderSize += SizeOfLengthField; 417 | StartOffset += SizeOfLengthField; 418 | } 419 | 420 | BOOL overflow_e = FALSE; 421 | if (CellSize > RecordToRecord) // overflow 422 | { 423 | RecordToRecord -= HeaderSize; 424 | 425 | BYTE PageNumber[4]; 426 | memcpy(PageNumber, &Page.Page[StartOffset + RecordToRecord - 4], 4); 427 | INT OverflowPageNumberStart = ut.LongIntToByte(PageNumber, 4); 428 | ParsingRecordContainOverflow(Page, 429 | OverflowPageNumberStart, 430 | StartOffset, 431 | RecordToRecord - 4, // 레코드 크기. 432 | CellSize, // 전체 셀 사이즈로 하자. 433 | table, 434 | overflow_e); 435 | } 436 | 437 | else 438 | ParsingRecord(Page, StartOffset, EndOffset, table); 439 | } 440 | 441 | 442 | } 443 | VOID SQLiteRecovery::GetTableSchema(){ 444 | 445 | InitSQLiteMasterTable(); 446 | 447 | SQLitePage FirstPage; 448 | FirstPage.Page = new BYTE[PageSize + 1]; 449 | memcpy(FirstPage.Page, &SQLITE_BUFFER[0], PageSize); 450 | 451 | INT PageNum = GetLeafPage(&FirstPage, sqlite_master.RootPageNum, &sqlite_master); 452 | delete[] FirstPage.Page; 453 | 454 | if (PageNum == sqlite_master.RootPageNum) 455 | sqlite_master.LeafPageNum.push_back(PageNum); 456 | // 첫 페이지에서 leaf일때 457 | 458 | for (int i = 0; i < sqlite_master.LeafPageNum.size(); i++){ 459 | 460 | INT PageOffset = (sqlite_master.LeafPageNum[i] - 1) * PageSize; 461 | 462 | if (PageOffset > FileSize || PageOffset < 0) 463 | continue; 464 | 465 | SQLitePage Page; 466 | INT TEST; 467 | 468 | Page.PageNumber = sqlite_master.LeafPageNum[i]; 469 | Page.Page = new BYTE[PageSize + 1]; 470 | 471 | TEST = sqlite_master.DeletedRecord.size(); 472 | memcpy(Page.Page, &SQLITE_BUFFER[PageOffset], PageSize); 473 | if(sqlite_master.LeafPageNum.size() == 1) 474 | GetSchemaCell_First(Page, &sqlite_master); 475 | else 476 | GetSchemaCell(Page, &sqlite_master); 477 | 478 | delete[] Page.Page; 479 | 480 | } 481 | SetSchemaInformationFromSQLITEMaster(); 482 | } 483 | std::vector SQLiteRecovery::GetSchemaInformation(CString input) 484 | { 485 | 486 | CString Field = input; 487 | 488 | CString temp; 489 | std::vector parse; 490 | SQLITE_COLUMN write; 491 | 492 | Field.Replace(L"\r\n", L""); 493 | Field.Replace(L"\n", L""); 494 | Field.Replace(L"\r", L""); 495 | Field.Replace(L" ", L""); 496 | Field.Replace(L"\t", L""); 497 | Field = Field.Right(Field.GetLength() - Field.Find(L"(") - 1); 498 | while (Field.GetLength() != 0/*temp.Find(ex, i) < 0 && cnt < TotalCnt*/) 499 | { 500 | 501 | if (Field.Find(L",") == -1){ 502 | 503 | temp = Field; 504 | Field = L""; 505 | 506 | } 507 | else{ 508 | 509 | temp = Field.Left(Field.Find(L",")); 510 | Field = Field.Right(Field.GetLength() - Field.Find(L",") - 1); 511 | } 512 | 513 | int pos = 0; 514 | ////////////////////////////// 515 | if (temp.Find(_T("INTEGER"))!=-1) 516 | { 517 | write.Type = L"INTEGER"; 518 | pos = temp.Find(_T("INTEGER")); 519 | } 520 | else if (temp.Find(_T("TEXT"))!=-1) 521 | { 522 | write.Type = L"TEXT"; 523 | pos = temp.Find(_T("TEXT")); 524 | } 525 | else if (temp.Find(_T("BLOB"))!=-1) 526 | { 527 | write.Type = L"BLOB"; 528 | pos = temp.Find(_T("BLOB")); 529 | } 530 | write.ColumnName = temp.Left(pos); 531 | /* 532 | ((pos = temp.Find(_T("INTEGER"))) || (pos = temp.Find(_T("TEXT"))) || (pos = temp.Find(_T("BLOB")))) 533 | { 534 | write.ColumnName = temp.Left(pos); 535 | CString type_key = temp.Mid(pos); 536 | if (type_key.Find(L" ")) 537 | write.Type = type_key.Left(type_key.Find(L" ")); 538 | else 539 | write.Type = type_key; 540 | } 541 | 542 | // while (temp.GetAt(0) == ' '){ 543 | // temp = temp.Right(temp.GetLength() - 1); 544 | // } 545 | */ 546 | 547 | write.ColumnName.Replace(L" ", L""); 548 | // write.Type.Replace(L" ", L""); 549 | 550 | 551 | // AfxExtractSubString(write.ColumnName, temp, 0, ' '); 552 | // AfxExtractSubString(write.Type, temp, 1, ' '); 553 | 554 | parse.push_back(write); 555 | 556 | } 557 | return parse; 558 | } 559 | VOID SQLiteRecovery::SetSchemaInformationFromSQLITEMaster(){ 560 | 561 | //0131 DeletedRecord -> NormalRecord 562 | 563 | for (int i = 0; i < sqlite_master.NormalRecord.size(); i++){ 564 | 565 | CString data(sqlite_master.NormalRecord[i].columns[0].Data); 566 | if (data.Find(L"table") != -1){ 567 | 568 | 569 | SQLITE_TABLE table; 570 | 571 | 572 | table.RootPageNum = ut.LongIntToByte(sqlite_master.NormalRecord[i].columns[3].Data, sqlite_master.NormalRecord[i].columns[3].Length); 573 | table.TableName = sqlite_master.NormalRecord[i].columns[2].Data; 574 | 575 | CString Query(sqlite_master.NormalRecord[i].columns[4].Data); 576 | 577 | 578 | std::vector columns = GetSchemaInformation(Query); 579 | 580 | table.Column = new SQLITE_COLUMN[columns.size()]; 581 | 582 | for (int idx = 0; idx < columns.size(); idx++){ 583 | 584 | // CString ColumnType = columns[idx].Type.MakeUpper(); 585 | 586 | /* if (ColumnType.Find(_T("INT")) != -1 || ColumnType.Find(_T("DECIMAL")) != -1 587 | || ColumnType.Find(_T("REAL")) != -1 || ColumnType.Find(_T("DOUBLE")) != -1 || 588 | ColumnType.Find(_T("NUMERIC")) != -1 || (ColumnType.Find(_T("DATE")) != -1 && ColumnType.Compare(_T("DATETIME")) != 0) || 589 | ColumnType.Find(_T("BOOL")) != -1 || ColumnType.Find(_T("LONG")) != -1) 590 | { 591 | table.Column[idx].Type = _T("INTEGER"); 592 | } 593 | else if (ColumnType.Find(_T("TEXT")) != -1 || ColumnType.Find(_T("CHAR")) != -1 || 594 | ColumnType.Find(_T("STRING")) != -1 || ColumnType.Find(_T("DATETIME")) != -1 || ColumnType.Find(_T("NVARCHAR")) != -1) 595 | { 596 | table.Column[idx].Type = _T("TEXT"); 597 | } 598 | else if (ColumnType.Find(_T("BLOB")) != -1 || ColumnType.Find(_T("CLOB")) != -1) 599 | { 600 | table.Column[idx].Type = _T("BLOB"); 601 | } 602 | */ 603 | table.Column[idx].Type = columns[idx].Type; 604 | table.Column[idx].ColumnName = columns[idx].ColumnName; 605 | 606 | } 607 | 608 | 609 | 610 | //deleted_table.push_back(table); 611 | table.NumberOfField = columns.size(); 612 | tables.push_back(table); 613 | 614 | } 615 | 616 | 617 | 618 | } 619 | 620 | 621 | /* 622 | 623 | 리프노드 수집절차~! ㄴ 624 | 625 | 나중에 deleted_table 을 tables 로 옮겨야함 626 | 627 | */ 628 | for (int i = 0; i < tables.size(); i++){ 629 | 630 | 631 | /*if (deleted_table[i].RootPageNum != 0){ 632 | INT PageNum = GetLeafPage(deleted_table[i].RootPageNum, &deleted_table[i]); 633 | if (PageNum == deleted_table[i].RootPageNum) 634 | deleted_table[i].LeafPageNum.push_back(PageNum); 635 | }*/ 636 | 637 | if (tables[i].RootPageNum != 0){ 638 | INT PageNum = GetLeafPage(tables[i].RootPageNum, &tables[i]); 639 | if (PageNum == tables[i].RootPageNum) 640 | tables[i].LeafPageNum.push_back(PageNum); 641 | } 642 | 643 | } 644 | 645 | 646 | 647 | } 648 | -------------------------------------------------------------------------------- /SQLiteRecover/UTF8Checker.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "UTF8Checker.h" 3 | 4 | 5 | 6 | INT UTF8Checker::GetByteSize(BYTE str){ 7 | 8 | INT Size = 0; 9 | BYTE Bitmap = 0x80; 10 | BYTE Checker = str & Bitmap; 11 | while (Checker) 12 | { 13 | Bitmap = Bitmap >> 1; 14 | Checker = str & Bitmap; 15 | Size += 1; 16 | } 17 | 18 | return Size; 19 | } 20 | 21 | 22 | BOOL UTF8Checker::CheckString(BYTE* str, INT Length){ 23 | 24 | 25 | INT idx = 0; 26 | while (idx < Length){ 27 | 28 | INT Bitmap = str[idx] & 0x80; 29 | if (Bitmap){ 30 | 31 | INT Size = GetByteSize(str[idx]); 32 | 33 | if (Size == 1){ 34 | return FALSE; 35 | } 36 | 37 | for (int i = 1; i < Size; i++){ 38 | 39 | if (str[idx + i] & 0x80) 40 | { 41 | // 42 | } 43 | else{ 44 | return FALSE; 45 | } 46 | 47 | } 48 | //for (int) 49 | idx += Size; 50 | 51 | 52 | } 53 | else{ 54 | idx++; 55 | } 56 | 57 | } 58 | 59 | return TRUE; 60 | } 61 | 62 | -------------------------------------------------------------------------------- /SQLiteRecover/UTF8Checker.h: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #ifndef __UTF8CHECKER_H__ 3 | #define __UTF8CHECKER_H__ 4 | 5 | #define UTF8ByteHeader 0x10 6 | 7 | 8 | class UTF8Checker{ 9 | 10 | private: 11 | INT GetByteSize(BYTE str); 12 | public: 13 | BOOL CheckString(BYTE* str, INT Length); 14 | }; 15 | 16 | #endif -------------------------------------------------------------------------------- /SQLiteRecover/UTIL.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/UTIL.cpp -------------------------------------------------------------------------------- /SQLiteRecover/UTIL.h: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #ifndef __UTIL_H__ 3 | #define __UTIL_H__ 4 | 5 | 6 | class UTIL 7 | { 8 | public: 9 | unsigned __int64 IntToByte(BYTE src[], int length); 10 | unsigned __int64 LongIntToByte(BYTE src[], int length); 11 | int LittleEndianToInteger(BYTE src[]); 12 | int LittleEndianToInteger(BYTE src[], INT length); 13 | CString convertUTF8toANSI(CString str); 14 | CString unixTimeToStrTime(INT32 unixtime); 15 | char* UTF8toANSI(char *pszCode); 16 | 17 | CString UTFtoANSI(char * pszCode); 18 | }; 19 | 20 | #endif -------------------------------------------------------------------------------- /SQLiteRecover/page: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/page -------------------------------------------------------------------------------- /SQLiteRecover/sqlite3.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/sqlite3.dll -------------------------------------------------------------------------------- /SQLiteRecover/sqlite3.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** 2001 September 15 3 | ** 4 | ** The author disclaims copyright to this source code. In place of 5 | ** a legal notice, here is a blessing: 6 | ** 7 | ** May you do good and not evil. 8 | ** May you find forgiveness for yourself and forgive others. 9 | ** May you share freely, never taking more than you give. 10 | ** 11 | ************************************************************************* 12 | ** This header file defines the interface that the SQLite library 13 | ** presents to client programs. 14 | ** 15 | ** @(#) $Id: sqlite.h.in,v 1.165 2006/04/04 01:54:55 drh Exp $ 16 | */ 17 | #ifndef _SQLITE3_H_ 18 | #define _SQLITE3_H_ 19 | #include /* Needed for the definition of va_list */ 20 | 21 | /* 22 | ** Make sure we can call this stuff from C++. 23 | */ 24 | #ifdef __cplusplus 25 | extern "C" { 26 | #endif 27 | 28 | /* 29 | ** The version of the SQLite library. 30 | */ 31 | #ifdef SQLITE_VERSION 32 | # undef SQLITE_VERSION 33 | #endif 34 | #define SQLITE_VERSION "3.3.6" 35 | 36 | /* 37 | ** The format of the version string is "X.Y.Z", where 38 | ** X is the major version number, Y is the minor version number and Z 39 | ** is the release number. The trailing string is often "alpha" or "beta". 40 | ** For example "3.1.1beta". 41 | ** 42 | ** The SQLITE_VERSION_NUMBER is an integer with the value 43 | ** (X*100000 + Y*1000 + Z). For example, for version "3.1.1beta", 44 | ** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using 45 | ** version 3.1.1 or greater at compile time, programs may use the test 46 | ** (SQLITE_VERSION_NUMBER>=3001001). 47 | */ 48 | #ifdef SQLITE_VERSION_NUMBER 49 | # undef SQLITE_VERSION_NUMBER 50 | #endif 51 | #define SQLITE_VERSION_NUMBER 3003006 52 | 53 | /* 54 | ** The version string is also compiled into the library so that a program 55 | ** can check to make sure that the lib*.a file and the *.h file are from 56 | ** the same version. The sqlite3_libversion() function returns a pointer 57 | ** to the sqlite3_version variable - useful in DLLs which cannot access 58 | ** global variables. 59 | */ 60 | extern const char sqlite3_version[]; 61 | const char *sqlite3_libversion(void); 62 | 63 | /* 64 | ** Return the value of the SQLITE_VERSION_NUMBER macro when the 65 | ** library was compiled. 66 | */ 67 | int sqlite3_libversion_number(void); 68 | 69 | /* 70 | ** Each open sqlite database is represented by an instance of the 71 | ** following opaque structure. 72 | */ 73 | typedef struct sqlite3 sqlite3; 74 | 75 | 76 | /* 77 | ** Some compilers do not support the "long long" datatype. So we have 78 | ** to do a typedef that for 64-bit integers that depends on what compiler 79 | ** is being used. 80 | */ 81 | #ifdef SQLITE_INT64_TYPE 82 | typedef SQLITE_INT64_TYPE sqlite_int64; 83 | typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; 84 | #elif defined(_MSC_VER) || defined(__BORLANDC__) 85 | typedef __int64 sqlite_int64; 86 | typedef unsigned __int64 sqlite_uint64; 87 | #else 88 | typedef long long int sqlite_int64; 89 | typedef unsigned long long int sqlite_uint64; 90 | #endif 91 | 92 | /* 93 | ** If compiling for a processor that lacks floating point support, 94 | ** substitute integer for floating-point 95 | */ 96 | #ifdef SQLITE_OMIT_FLOATING_POINT 97 | # define double sqlite_int64 98 | #endif 99 | 100 | /* 101 | ** A function to close the database. 102 | ** 103 | ** Call this function with a pointer to a structure that was previously 104 | ** returned from sqlite3_open() and the corresponding database will by closed. 105 | ** 106 | ** All SQL statements prepared using sqlite3_prepare() or 107 | ** sqlite3_prepare16() must be deallocated using sqlite3_finalize() before 108 | ** this routine is called. Otherwise, SQLITE_BUSY is returned and the 109 | ** database connection remains open. 110 | */ 111 | int sqlite3_close(sqlite3 *); 112 | 113 | /* 114 | ** The type for a callback function. 115 | */ 116 | typedef int (*sqlite3_callback)(void*,int,char**, char**); 117 | 118 | /* 119 | ** A function to executes one or more statements of SQL. 120 | ** 121 | ** If one or more of the SQL statements are queries, then 122 | ** the callback function specified by the 3rd parameter is 123 | ** invoked once for each row of the query result. This callback 124 | ** should normally return 0. If the callback returns a non-zero 125 | ** value then the query is aborted, all subsequent SQL statements 126 | ** are skipped and the sqlite3_exec() function returns the SQLITE_ABORT. 127 | ** 128 | ** The 4th parameter is an arbitrary pointer that is passed 129 | ** to the callback function as its first parameter. 130 | ** 131 | ** The 2nd parameter to the callback function is the number of 132 | ** columns in the query result. The 3rd parameter to the callback 133 | ** is an array of strings holding the values for each column. 134 | ** The 4th parameter to the callback is an array of strings holding 135 | ** the names of each column. 136 | ** 137 | ** The callback function may be NULL, even for queries. A NULL 138 | ** callback is not an error. It just means that no callback 139 | ** will be invoked. 140 | ** 141 | ** If an error occurs while parsing or evaluating the SQL (but 142 | ** not while executing the callback) then an appropriate error 143 | ** message is written into memory obtained from malloc() and 144 | ** *errmsg is made to point to that message. The calling function 145 | ** is responsible for freeing the memory that holds the error 146 | ** message. Use sqlite3_free() for this. If errmsg==NULL, 147 | ** then no error message is ever written. 148 | ** 149 | ** The return value is is SQLITE_OK if there are no errors and 150 | ** some other return code if there is an error. The particular 151 | ** return value depends on the type of error. 152 | ** 153 | ** If the query could not be executed because a database file is 154 | ** locked or busy, then this function returns SQLITE_BUSY. (This 155 | ** behavior can be modified somewhat using the sqlite3_busy_handler() 156 | ** and sqlite3_busy_timeout() functions below.) 157 | */ 158 | int sqlite3_exec( 159 | sqlite3*, /* An open database */ 160 | const char *sql, /* SQL to be executed */ 161 | sqlite3_callback, /* Callback function */ 162 | void *, /* 1st argument to callback function */ 163 | char **errmsg /* Error msg written here */ 164 | ); 165 | 166 | /* 167 | ** Return values for sqlite3_exec() and sqlite3_step() 168 | */ 169 | #define SQLITE_OK 0 /* Successful result */ 170 | /* beginning-of-error-codes */ 171 | #define SQLITE_ERROR 1 /* SQL error or missing database */ 172 | #define SQLITE_INTERNAL 2 /* NOT USED. Internal logic error in SQLite */ 173 | #define SQLITE_PERM 3 /* Access permission denied */ 174 | #define SQLITE_ABORT 4 /* Callback routine requested an abort */ 175 | #define SQLITE_BUSY 5 /* The database file is locked */ 176 | #define SQLITE_LOCKED 6 /* A table in the database is locked */ 177 | #define SQLITE_NOMEM 7 /* A malloc() failed */ 178 | #define SQLITE_READONLY 8 /* Attempt to write a readonly database */ 179 | #define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ 180 | #define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ 181 | #define SQLITE_CORRUPT 11 /* The database disk image is malformed */ 182 | #define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ 183 | #define SQLITE_FULL 13 /* Insertion failed because database is full */ 184 | #define SQLITE_CANTOPEN 14 /* Unable to open the database file */ 185 | #define SQLITE_PROTOCOL 15 /* Database lock protocol error */ 186 | #define SQLITE_EMPTY 16 /* Database is empty */ 187 | #define SQLITE_SCHEMA 17 /* The database schema changed */ 188 | #define SQLITE_TOOBIG 18 /* NOT USED. Too much data for one row */ 189 | #define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation */ 190 | #define SQLITE_MISMATCH 20 /* Data type mismatch */ 191 | #define SQLITE_MISUSE 21 /* Library used incorrectly */ 192 | #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ 193 | #define SQLITE_AUTH 23 /* Authorization denied */ 194 | #define SQLITE_FORMAT 24 /* Auxiliary database format error */ 195 | #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ 196 | #define SQLITE_NOTADB 26 /* File opened that is not a database file */ 197 | #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ 198 | #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ 199 | /* end-of-error-codes */ 200 | 201 | /* 202 | ** Each entry in an SQLite table has a unique integer key. (The key is 203 | ** the value of the INTEGER PRIMARY KEY column if there is such a column, 204 | ** otherwise the key is generated at random. The unique key is always 205 | ** available as the ROWID, OID, or _ROWID_ column.) The following routine 206 | ** returns the integer key of the most recent insert in the database. 207 | ** 208 | ** This function is similar to the mysql_insert_id() function from MySQL. 209 | */ 210 | sqlite_int64 sqlite3_last_insert_rowid(sqlite3*); 211 | 212 | /* 213 | ** This function returns the number of database rows that were changed 214 | ** (or inserted or deleted) by the most recent called sqlite3_exec(). 215 | ** 216 | ** All changes are counted, even if they were later undone by a 217 | ** ROLLBACK or ABORT. Except, changes associated with creating and 218 | ** dropping tables are not counted. 219 | ** 220 | ** If a callback invokes sqlite3_exec() recursively, then the changes 221 | ** in the inner, recursive call are counted together with the changes 222 | ** in the outer call. 223 | ** 224 | ** SQLite implements the command "DELETE FROM table" without a WHERE clause 225 | ** by dropping and recreating the table. (This is much faster than going 226 | ** through and deleting individual elements form the table.) Because of 227 | ** this optimization, the change count for "DELETE FROM table" will be 228 | ** zero regardless of the number of elements that were originally in the 229 | ** table. To get an accurate count of the number of rows deleted, use 230 | ** "DELETE FROM table WHERE 1" instead. 231 | */ 232 | int sqlite3_changes(sqlite3*); 233 | 234 | /* 235 | ** This function returns the number of database rows that have been 236 | ** modified by INSERT, UPDATE or DELETE statements since the database handle 237 | ** was opened. This includes UPDATE, INSERT and DELETE statements executed 238 | ** as part of trigger programs. All changes are counted as soon as the 239 | ** statement that makes them is completed (when the statement handle is 240 | ** passed to sqlite3_reset() or sqlite_finalise()). 241 | ** 242 | ** SQLite implements the command "DELETE FROM table" without a WHERE clause 243 | ** by dropping and recreating the table. (This is much faster than going 244 | ** through and deleting individual elements form the table.) Because of 245 | ** this optimization, the change count for "DELETE FROM table" will be 246 | ** zero regardless of the number of elements that were originally in the 247 | ** table. To get an accurate count of the number of rows deleted, use 248 | ** "DELETE FROM table WHERE 1" instead. 249 | */ 250 | int sqlite3_total_changes(sqlite3*); 251 | 252 | /* This function causes any pending database operation to abort and 253 | ** return at its earliest opportunity. This routine is typically 254 | ** called in response to a user action such as pressing "Cancel" 255 | ** or Ctrl-C where the user wants a long query operation to halt 256 | ** immediately. 257 | */ 258 | void sqlite3_interrupt(sqlite3*); 259 | 260 | 261 | /* These functions return true if the given input string comprises 262 | ** one or more complete SQL statements. For the sqlite3_complete() call, 263 | ** the parameter must be a nul-terminated UTF-8 string. For 264 | ** sqlite3_complete16(), a nul-terminated machine byte order UTF-16 string 265 | ** is required. 266 | ** 267 | ** The algorithm is simple. If the last token other than spaces 268 | ** and comments is a semicolon, then return true. otherwise return 269 | ** false. 270 | */ 271 | int sqlite3_complete(const char *sql); 272 | int sqlite3_complete16(const void *sql); 273 | 274 | /* 275 | ** This routine identifies a callback function that is invoked 276 | ** whenever an attempt is made to open a database table that is 277 | ** currently locked by another process or thread. If the busy callback 278 | ** is NULL, then sqlite3_exec() returns SQLITE_BUSY immediately if 279 | ** it finds a locked table. If the busy callback is not NULL, then 280 | ** sqlite3_exec() invokes the callback with three arguments. The 281 | ** second argument is the name of the locked table and the third 282 | ** argument is the number of times the table has been busy. If the 283 | ** busy callback returns 0, then sqlite3_exec() immediately returns 284 | ** SQLITE_BUSY. If the callback returns non-zero, then sqlite3_exec() 285 | ** tries to open the table again and the cycle repeats. 286 | ** 287 | ** The default busy callback is NULL. 288 | ** 289 | ** Sqlite is re-entrant, so the busy handler may start a new query. 290 | ** (It is not clear why anyone would every want to do this, but it 291 | ** is allowed, in theory.) But the busy handler may not close the 292 | ** database. Closing the database from a busy handler will delete 293 | ** data structures out from under the executing query and will 294 | ** probably result in a coredump. 295 | */ 296 | int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); 297 | 298 | /* 299 | ** This routine sets a busy handler that sleeps for a while when a 300 | ** table is locked. The handler will sleep multiple times until 301 | ** at least "ms" milleseconds of sleeping have been done. After 302 | ** "ms" milleseconds of sleeping, the handler returns 0 which 303 | ** causes sqlite3_exec() to return SQLITE_BUSY. 304 | ** 305 | ** Calling this routine with an argument less than or equal to zero 306 | ** turns off all busy handlers. 307 | */ 308 | int sqlite3_busy_timeout(sqlite3*, int ms); 309 | 310 | /* 311 | ** This next routine is really just a wrapper around sqlite3_exec(). 312 | ** Instead of invoking a user-supplied callback for each row of the 313 | ** result, this routine remembers each row of the result in memory 314 | ** obtained from malloc(), then returns all of the result after the 315 | ** query has finished. 316 | ** 317 | ** As an example, suppose the query result where this table: 318 | ** 319 | ** Name | Age 320 | ** ----------------------- 321 | ** Alice | 43 322 | ** Bob | 28 323 | ** Cindy | 21 324 | ** 325 | ** If the 3rd argument were &azResult then after the function returns 326 | ** azResult will contain the following data: 327 | ** 328 | ** azResult[0] = "Name"; 329 | ** azResult[1] = "Age"; 330 | ** azResult[2] = "Alice"; 331 | ** azResult[3] = "43"; 332 | ** azResult[4] = "Bob"; 333 | ** azResult[5] = "28"; 334 | ** azResult[6] = "Cindy"; 335 | ** azResult[7] = "21"; 336 | ** 337 | ** Notice that there is an extra row of data containing the column 338 | ** headers. But the *nrow return value is still 3. *ncolumn is 339 | ** set to 2. In general, the number of values inserted into azResult 340 | ** will be ((*nrow) + 1)*(*ncolumn). 341 | ** 342 | ** After the calling function has finished using the result, it should 343 | ** pass the result data pointer to sqlite3_free_table() in order to 344 | ** release the memory that was malloc-ed. Because of the way the 345 | ** malloc() happens, the calling function must not try to call 346 | ** free() directly. Only sqlite3_free_table() is able to release 347 | ** the memory properly and safely. 348 | ** 349 | ** The return value of this routine is the same as from sqlite3_exec(). 350 | */ 351 | int sqlite3_get_table( 352 | sqlite3*, /* An open database */ 353 | const char *sql, /* SQL to be executed */ 354 | char ***resultp, /* Result written to a char *[] that this points to */ 355 | int *nrow, /* Number of result rows written here */ 356 | int *ncolumn, /* Number of result columns written here */ 357 | char **errmsg /* Error msg written here */ 358 | ); 359 | 360 | /* 361 | ** Call this routine to free the memory that sqlite3_get_table() allocated. 362 | */ 363 | void sqlite3_free_table(char **result); 364 | 365 | /* 366 | ** The following routines are variants of the "sprintf()" from the 367 | ** standard C library. The resulting string is written into memory 368 | ** obtained from malloc() so that there is never a possiblity of buffer 369 | ** overflow. These routines also implement some additional formatting 370 | ** options that are useful for constructing SQL statements. 371 | ** 372 | ** The strings returned by these routines should be freed by calling 373 | ** sqlite3_free(). 374 | ** 375 | ** All of the usual printf formatting options apply. In addition, there 376 | ** is a "%q" option. %q works like %s in that it substitutes a null-terminated 377 | ** string from the argument list. But %q also doubles every '\'' character. 378 | ** %q is designed for use inside a string literal. By doubling each '\'' 379 | ** character it escapes that character and allows it to be inserted into 380 | ** the string. 381 | ** 382 | ** For example, so some string variable contains text as follows: 383 | ** 384 | ** char *zText = "It's a happy day!"; 385 | ** 386 | ** We can use this text in an SQL statement as follows: 387 | ** 388 | ** char *z = sqlite3_mprintf("INSERT INTO TABLES('%q')", zText); 389 | ** sqlite3_exec(db, z, callback1, 0, 0); 390 | ** sqlite3_free(z); 391 | ** 392 | ** Because the %q format string is used, the '\'' character in zText 393 | ** is escaped and the SQL generated is as follows: 394 | ** 395 | ** INSERT INTO table1 VALUES('It''s a happy day!') 396 | ** 397 | ** This is correct. Had we used %s instead of %q, the generated SQL 398 | ** would have looked like this: 399 | ** 400 | ** INSERT INTO table1 VALUES('It's a happy day!'); 401 | ** 402 | ** This second example is an SQL syntax error. As a general rule you 403 | ** should always use %q instead of %s when inserting text into a string 404 | ** literal. 405 | */ 406 | char *sqlite3_mprintf(const char*,...); 407 | char *sqlite3_vmprintf(const char*, va_list); 408 | void sqlite3_free(char *z); 409 | char *sqlite3_snprintf(int,char*,const char*, ...); 410 | 411 | #ifndef SQLITE_OMIT_AUTHORIZATION 412 | /* 413 | ** This routine registers a callback with the SQLite library. The 414 | ** callback is invoked (at compile-time, not at run-time) for each 415 | ** attempt to access a column of a table in the database. The callback 416 | ** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire 417 | ** SQL statement should be aborted with an error and SQLITE_IGNORE 418 | ** if the column should be treated as a NULL value. 419 | */ 420 | int sqlite3_set_authorizer( 421 | sqlite3*, 422 | int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), 423 | void *pUserData 424 | ); 425 | #endif 426 | 427 | /* 428 | ** The second parameter to the access authorization function above will 429 | ** be one of the values below. These values signify what kind of operation 430 | ** is to be authorized. The 3rd and 4th parameters to the authorization 431 | ** function will be parameters or NULL depending on which of the following 432 | ** codes is used as the second parameter. The 5th parameter is the name 433 | ** of the database ("main", "temp", etc.) if applicable. The 6th parameter 434 | ** is the name of the inner-most trigger or view that is responsible for 435 | ** the access attempt or NULL if this access attempt is directly from 436 | ** input SQL code. 437 | ** 438 | ** Arg-3 Arg-4 439 | */ 440 | #define SQLITE_COPY 0 /* Table Name File Name */ 441 | #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ 442 | #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ 443 | #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ 444 | #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ 445 | #define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ 446 | #define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ 447 | #define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ 448 | #define SQLITE_CREATE_VIEW 8 /* View Name NULL */ 449 | #define SQLITE_DELETE 9 /* Table Name NULL */ 450 | #define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ 451 | #define SQLITE_DROP_TABLE 11 /* Table Name NULL */ 452 | #define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ 453 | #define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ 454 | #define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ 455 | #define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ 456 | #define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ 457 | #define SQLITE_DROP_VIEW 17 /* View Name NULL */ 458 | #define SQLITE_INSERT 18 /* Table Name NULL */ 459 | #define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ 460 | #define SQLITE_READ 20 /* Table Name Column Name */ 461 | #define SQLITE_SELECT 21 /* NULL NULL */ 462 | #define SQLITE_TRANSACTION 22 /* NULL NULL */ 463 | #define SQLITE_UPDATE 23 /* Table Name Column Name */ 464 | #define SQLITE_ATTACH 24 /* Filename NULL */ 465 | #define SQLITE_DETACH 25 /* Database Name NULL */ 466 | #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ 467 | #define SQLITE_REINDEX 27 /* Index Name NULL */ 468 | #define SQLITE_ANALYZE 28 /* Table Name NULL */ 469 | 470 | 471 | /* 472 | ** The return value of the authorization function should be one of the 473 | ** following constants: 474 | */ 475 | /* #define SQLITE_OK 0 // Allow access (This is actually defined above) */ 476 | #define SQLITE_DENY 1 /* Abort the SQL statement with an error */ 477 | #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ 478 | 479 | /* 480 | ** Register a function for tracing SQL command evaluation. The function 481 | ** registered by sqlite3_trace() is invoked at the first sqlite3_step() 482 | ** for the evaluation of an SQL statement. The function registered by 483 | ** sqlite3_profile() runs at the end of each SQL statement and includes 484 | ** information on how long that statement ran. 485 | ** 486 | ** The sqlite3_profile() API is currently considered experimental and 487 | ** is subject to change. 488 | */ 489 | void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); 490 | void *sqlite3_profile(sqlite3*, 491 | void(*xProfile)(void*,const char*,sqlite_uint64), void*); 492 | 493 | /* 494 | ** This routine configures a callback function - the progress callback - that 495 | ** is invoked periodically during long running calls to sqlite3_exec(), 496 | ** sqlite3_step() and sqlite3_get_table(). An example use for this API is to 497 | ** keep a GUI updated during a large query. 498 | ** 499 | ** The progress callback is invoked once for every N virtual machine opcodes, 500 | ** where N is the second argument to this function. The progress callback 501 | ** itself is identified by the third argument to this function. The fourth 502 | ** argument to this function is a void pointer passed to the progress callback 503 | ** function each time it is invoked. 504 | ** 505 | ** If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results 506 | ** in less than N opcodes being executed, then the progress callback is not 507 | ** invoked. 508 | ** 509 | ** To remove the progress callback altogether, pass NULL as the third 510 | ** argument to this function. 511 | ** 512 | ** If the progress callback returns a result other than 0, then the current 513 | ** query is immediately terminated and any database changes rolled back. If the 514 | ** query was part of a larger transaction, then the transaction is not rolled 515 | ** back and remains active. The sqlite3_exec() call returns SQLITE_ABORT. 516 | ** 517 | ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** 518 | */ 519 | void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); 520 | 521 | /* 522 | ** Register a callback function to be invoked whenever a new transaction 523 | ** is committed. The pArg argument is passed through to the callback. 524 | ** callback. If the callback function returns non-zero, then the commit 525 | ** is converted into a rollback. 526 | ** 527 | ** If another function was previously registered, its pArg value is returned. 528 | ** Otherwise NULL is returned. 529 | ** 530 | ** Registering a NULL function disables the callback. 531 | ** 532 | ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** 533 | */ 534 | void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); 535 | 536 | /* 537 | ** Open the sqlite database file "filename". The "filename" is UTF-8 538 | ** encoded for sqlite3_open() and UTF-16 encoded in the native byte order 539 | ** for sqlite3_open16(). An sqlite3* handle is returned in *ppDb, even 540 | ** if an error occurs. If the database is opened (or created) successfully, 541 | ** then SQLITE_OK is returned. Otherwise an error code is returned. The 542 | ** sqlite3_errmsg() or sqlite3_errmsg16() routines can be used to obtain 543 | ** an English language description of the error. 544 | ** 545 | ** If the database file does not exist, then a new database is created. 546 | ** The encoding for the database is UTF-8 if sqlite3_open() is called and 547 | ** UTF-16 if sqlite3_open16 is used. 548 | ** 549 | ** Whether or not an error occurs when it is opened, resources associated 550 | ** with the sqlite3* handle should be released by passing it to 551 | ** sqlite3_close() when it is no longer required. 552 | */ 553 | int sqlite3_open( 554 | const char *filename, /* Database filename (UTF-8) */ 555 | sqlite3 **ppDb /* OUT: SQLite db handle */ 556 | ); 557 | int sqlite3_open16( 558 | const void *filename, /* Database filename (UTF-16) */ 559 | sqlite3 **ppDb /* OUT: SQLite db handle */ 560 | ); 561 | 562 | /* 563 | ** Return the error code for the most recent sqlite3_* API call associated 564 | ** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent 565 | ** API call was successful. 566 | ** 567 | ** Calls to many sqlite3_* functions set the error code and string returned 568 | ** by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16() 569 | ** (overwriting the previous values). Note that calls to sqlite3_errcode(), 570 | ** sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the 571 | ** results of future invocations. 572 | ** 573 | ** Assuming no other intervening sqlite3_* API calls are made, the error 574 | ** code returned by this function is associated with the same error as 575 | ** the strings returned by sqlite3_errmsg() and sqlite3_errmsg16(). 576 | */ 577 | int sqlite3_errcode(sqlite3 *db); 578 | 579 | /* 580 | ** Return a pointer to a UTF-8 encoded string describing in english the 581 | ** error condition for the most recent sqlite3_* API call. The returned 582 | ** string is always terminated by an 0x00 byte. 583 | ** 584 | ** The string "not an error" is returned when the most recent API call was 585 | ** successful. 586 | */ 587 | const char *sqlite3_errmsg(sqlite3*); 588 | 589 | /* 590 | ** Return a pointer to a UTF-16 native byte order encoded string describing 591 | ** in english the error condition for the most recent sqlite3_* API call. 592 | ** The returned string is always terminated by a pair of 0x00 bytes. 593 | ** 594 | ** The string "not an error" is returned when the most recent API call was 595 | ** successful. 596 | */ 597 | const void *sqlite3_errmsg16(sqlite3*); 598 | 599 | /* 600 | ** An instance of the following opaque structure is used to represent 601 | ** a compiled SQL statment. 602 | */ 603 | typedef struct sqlite3_stmt sqlite3_stmt; 604 | 605 | /* 606 | ** To execute an SQL query, it must first be compiled into a byte-code 607 | ** program using one of the following routines. The only difference between 608 | ** them is that the second argument, specifying the SQL statement to 609 | ** compile, is assumed to be encoded in UTF-8 for the sqlite3_prepare() 610 | ** function and UTF-16 for sqlite3_prepare16(). 611 | ** 612 | ** The first parameter "db" is an SQLite database handle. The second 613 | ** parameter "zSql" is the statement to be compiled, encoded as either 614 | ** UTF-8 or UTF-16 (see above). If the next parameter, "nBytes", is less 615 | ** than zero, then zSql is read up to the first nul terminator. If 616 | ** "nBytes" is not less than zero, then it is the length of the string zSql 617 | ** in bytes (not characters). 618 | ** 619 | ** *pzTail is made to point to the first byte past the end of the first 620 | ** SQL statement in zSql. This routine only compiles the first statement 621 | ** in zSql, so *pzTail is left pointing to what remains uncompiled. 622 | ** 623 | ** *ppStmt is left pointing to a compiled SQL statement that can be 624 | ** executed using sqlite3_step(). Or if there is an error, *ppStmt may be 625 | ** set to NULL. If the input text contained no SQL (if the input is and 626 | ** empty string or a comment) then *ppStmt is set to NULL. 627 | ** 628 | ** On success, SQLITE_OK is returned. Otherwise an error code is returned. 629 | */ 630 | int sqlite3_prepare( 631 | sqlite3 *db, /* Database handle */ 632 | const char *zSql, /* SQL statement, UTF-8 encoded */ 633 | int nBytes, /* Length of zSql in bytes. */ 634 | sqlite3_stmt **ppStmt, /* OUT: Statement handle */ 635 | const char **pzTail /* OUT: Pointer to unused portion of zSql */ 636 | ); 637 | int sqlite3_prepare16( 638 | sqlite3 *db, /* Database handle */ 639 | const void *zSql, /* SQL statement, UTF-16 encoded */ 640 | int nBytes, /* Length of zSql in bytes. */ 641 | sqlite3_stmt **ppStmt, /* OUT: Statement handle */ 642 | const void **pzTail /* OUT: Pointer to unused portion of zSql */ 643 | ); 644 | 645 | /* 646 | ** Pointers to the following two opaque structures are used to communicate 647 | ** with the implementations of user-defined functions. 648 | */ 649 | typedef struct sqlite3_context sqlite3_context; 650 | typedef struct Mem sqlite3_value; 651 | 652 | /* 653 | ** In the SQL strings input to sqlite3_prepare() and sqlite3_prepare16(), 654 | ** one or more literals can be replace by parameters "?" or ":AAA" or 655 | ** "$VVV" where AAA is an identifer and VVV is a variable name according 656 | ** to the syntax rules of the TCL programming language. 657 | ** The value of these parameters (also called "host parameter names") can 658 | ** be set using the routines listed below. 659 | ** 660 | ** In every case, the first parameter is a pointer to the sqlite3_stmt 661 | ** structure returned from sqlite3_prepare(). The second parameter is the 662 | ** index of the parameter. The first parameter as an index of 1. For 663 | ** named parameters (":AAA" or "$VVV") you can use 664 | ** sqlite3_bind_parameter_index() to get the correct index value given 665 | ** the parameters name. If the same named parameter occurs more than 666 | ** once, it is assigned the same index each time. 667 | ** 668 | ** The fifth parameter to sqlite3_bind_blob(), sqlite3_bind_text(), and 669 | ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or 670 | ** text after SQLite has finished with it. If the fifth argument is the 671 | ** special value SQLITE_STATIC, then the library assumes that the information 672 | ** is in static, unmanaged space and does not need to be freed. If the 673 | ** fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its 674 | ** own private copy of the data. 675 | ** 676 | ** The sqlite3_bind_* routine must be called before sqlite3_step() after 677 | ** an sqlite3_prepare() or sqlite3_reset(). Unbound parameterss are 678 | ** interpreted as NULL. 679 | */ 680 | int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); 681 | int sqlite3_bind_double(sqlite3_stmt*, int, double); 682 | int sqlite3_bind_int(sqlite3_stmt*, int, int); 683 | int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite_int64); 684 | int sqlite3_bind_null(sqlite3_stmt*, int); 685 | int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); 686 | int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); 687 | int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); 688 | 689 | /* 690 | ** Return the number of parameters in a compiled SQL statement. This 691 | ** routine was added to support DBD::SQLite. 692 | */ 693 | int sqlite3_bind_parameter_count(sqlite3_stmt*); 694 | 695 | /* 696 | ** Return the name of the i-th parameter. Ordinary parameters "?" are 697 | ** nameless and a NULL is returned. For parameters of the form :AAA or 698 | ** $VVV the complete text of the parameter name is returned, including 699 | ** the initial ":" or "$". NULL is returned if the index is out of range. 700 | */ 701 | const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); 702 | 703 | /* 704 | ** Return the index of a parameter with the given name. The name 705 | ** must match exactly. If no parameter with the given name is found, 706 | ** return 0. 707 | */ 708 | int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); 709 | 710 | /* 711 | ** Set all the parameters in the compiled SQL statement to NULL. 712 | */ 713 | int sqlite3_clear_bindings(sqlite3_stmt*); 714 | 715 | /* 716 | ** Return the number of columns in the result set returned by the compiled 717 | ** SQL statement. This routine returns 0 if pStmt is an SQL statement 718 | ** that does not return data (for example an UPDATE). 719 | */ 720 | int sqlite3_column_count(sqlite3_stmt *pStmt); 721 | 722 | /* 723 | ** The first parameter is a compiled SQL statement. This function returns 724 | ** the column heading for the Nth column of that statement, where N is the 725 | ** second function parameter. The string returned is UTF-8 for 726 | ** sqlite3_column_name() and UTF-16 for sqlite3_column_name16(). 727 | */ 728 | const char *sqlite3_column_name(sqlite3_stmt*,int); 729 | const void *sqlite3_column_name16(sqlite3_stmt*,int); 730 | 731 | /* 732 | ** The first parameter to the following calls is a compiled SQL statement. 733 | ** These functions return information about the Nth column returned by 734 | ** the statement, where N is the second function argument. 735 | ** 736 | ** If the Nth column returned by the statement is not a column value, 737 | ** then all of the functions return NULL. Otherwise, the return the 738 | ** name of the attached database, table and column that the expression 739 | ** extracts a value from. 740 | ** 741 | ** As with all other SQLite APIs, those postfixed with "16" return UTF-16 742 | ** encoded strings, the other functions return UTF-8. The memory containing 743 | ** the returned strings is valid until the statement handle is finalized(). 744 | ** 745 | ** These APIs are only available if the library was compiled with the 746 | ** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. 747 | */ 748 | const char *sqlite3_column_database_name(sqlite3_stmt*,int); 749 | const void *sqlite3_column_database_name16(sqlite3_stmt*,int); 750 | const char *sqlite3_column_table_name(sqlite3_stmt*,int); 751 | const void *sqlite3_column_table_name16(sqlite3_stmt*,int); 752 | const char *sqlite3_column_origin_name(sqlite3_stmt*,int); 753 | const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); 754 | 755 | /* 756 | ** The first parameter is a compiled SQL statement. If this statement 757 | ** is a SELECT statement, the Nth column of the returned result set 758 | ** of the SELECT is a table column then the declared type of the table 759 | ** column is returned. If the Nth column of the result set is not at table 760 | ** column, then a NULL pointer is returned. The returned string is always 761 | ** UTF-8 encoded. For example, in the database schema: 762 | ** 763 | ** CREATE TABLE t1(c1 VARIANT); 764 | ** 765 | ** And the following statement compiled: 766 | ** 767 | ** SELECT c1 + 1, c1 FROM t1; 768 | ** 769 | ** Then this routine would return the string "VARIANT" for the second 770 | ** result column (i==1), and a NULL pointer for the first result column 771 | ** (i==0). 772 | */ 773 | const char *sqlite3_column_decltype(sqlite3_stmt *, int i); 774 | 775 | /* 776 | ** The first parameter is a compiled SQL statement. If this statement 777 | ** is a SELECT statement, the Nth column of the returned result set 778 | ** of the SELECT is a table column then the declared type of the table 779 | ** column is returned. If the Nth column of the result set is not at table 780 | ** column, then a NULL pointer is returned. The returned string is always 781 | ** UTF-16 encoded. For example, in the database schema: 782 | ** 783 | ** CREATE TABLE t1(c1 INTEGER); 784 | ** 785 | ** And the following statement compiled: 786 | ** 787 | ** SELECT c1 + 1, c1 FROM t1; 788 | ** 789 | ** Then this routine would return the string "INTEGER" for the second 790 | ** result column (i==1), and a NULL pointer for the first result column 791 | ** (i==0). 792 | */ 793 | const void *sqlite3_column_decltype16(sqlite3_stmt*,int); 794 | 795 | /* 796 | ** After an SQL query has been compiled with a call to either 797 | ** sqlite3_prepare() or sqlite3_prepare16(), then this function must be 798 | ** called one or more times to execute the statement. 799 | ** 800 | ** The return value will be either SQLITE_BUSY, SQLITE_DONE, 801 | ** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. 802 | ** 803 | ** SQLITE_BUSY means that the database engine attempted to open 804 | ** a locked database and there is no busy callback registered. 805 | ** Call sqlite3_step() again to retry the open. 806 | ** 807 | ** SQLITE_DONE means that the statement has finished executing 808 | ** successfully. sqlite3_step() should not be called again on this virtual 809 | ** machine. 810 | ** 811 | ** If the SQL statement being executed returns any data, then 812 | ** SQLITE_ROW is returned each time a new row of data is ready 813 | ** for processing by the caller. The values may be accessed using 814 | ** the sqlite3_column_*() functions described below. sqlite3_step() 815 | ** is called again to retrieve the next row of data. 816 | ** 817 | ** SQLITE_ERROR means that a run-time error (such as a constraint 818 | ** violation) has occurred. sqlite3_step() should not be called again on 819 | ** the VM. More information may be found by calling sqlite3_errmsg(). 820 | ** 821 | ** SQLITE_MISUSE means that the this routine was called inappropriately. 822 | ** Perhaps it was called on a virtual machine that had already been 823 | ** finalized or on one that had previously returned SQLITE_ERROR or 824 | ** SQLITE_DONE. Or it could be the case the the same database connection 825 | ** is being used simulataneously by two or more threads. 826 | */ 827 | int sqlite3_step(sqlite3_stmt*); 828 | 829 | /* 830 | ** Return the number of values in the current row of the result set. 831 | ** 832 | ** After a call to sqlite3_step() that returns SQLITE_ROW, this routine 833 | ** will return the same value as the sqlite3_column_count() function. 834 | ** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or 835 | ** error code, or before sqlite3_step() has been called on a 836 | ** compiled SQL statement, this routine returns zero. 837 | */ 838 | int sqlite3_data_count(sqlite3_stmt *pStmt); 839 | 840 | /* 841 | ** Values are stored in the database in one of the following fundamental 842 | ** types. 843 | */ 844 | #define SQLITE_INTEGER 1 845 | #define SQLITE_FLOAT 2 846 | /* #define SQLITE_TEXT 3 // See below */ 847 | #define SQLITE_BLOB 4 848 | #define SQLITE_NULL 5 849 | 850 | /* 851 | ** SQLite version 2 defines SQLITE_TEXT differently. To allow both 852 | ** version 2 and version 3 to be included, undefine them both if a 853 | ** conflict is seen. Define SQLITE3_TEXT to be the version 3 value. 854 | */ 855 | #ifdef SQLITE_TEXT 856 | # undef SQLITE_TEXT 857 | #else 858 | # define SQLITE_TEXT 3 859 | #endif 860 | #define SQLITE3_TEXT 3 861 | 862 | /* 863 | ** The next group of routines returns information about the information 864 | ** in a single column of the current result row of a query. In every 865 | ** case the first parameter is a pointer to the SQL statement that is being 866 | ** executed (the sqlite_stmt* that was returned from sqlite3_prepare()) and 867 | ** the second argument is the index of the column for which information 868 | ** should be returned. iCol is zero-indexed. The left-most column as an 869 | ** index of 0. 870 | ** 871 | ** If the SQL statement is not currently point to a valid row, or if the 872 | ** the colulmn index is out of range, the result is undefined. 873 | ** 874 | ** These routines attempt to convert the value where appropriate. For 875 | ** example, if the internal representation is FLOAT and a text result 876 | ** is requested, sprintf() is used internally to do the conversion 877 | ** automatically. The following table details the conversions that 878 | ** are applied: 879 | ** 880 | ** Internal Type Requested Type Conversion 881 | ** ------------- -------------- -------------------------- 882 | ** NULL INTEGER Result is 0 883 | ** NULL FLOAT Result is 0.0 884 | ** NULL TEXT Result is an empty string 885 | ** NULL BLOB Result is a zero-length BLOB 886 | ** INTEGER FLOAT Convert from integer to float 887 | ** INTEGER TEXT ASCII rendering of the integer 888 | ** INTEGER BLOB Same as for INTEGER->TEXT 889 | ** FLOAT INTEGER Convert from float to integer 890 | ** FLOAT TEXT ASCII rendering of the float 891 | ** FLOAT BLOB Same as FLOAT->TEXT 892 | ** TEXT INTEGER Use atoi() 893 | ** TEXT FLOAT Use atof() 894 | ** TEXT BLOB No change 895 | ** BLOB INTEGER Convert to TEXT then use atoi() 896 | ** BLOB FLOAT Convert to TEXT then use atof() 897 | ** BLOB TEXT Add a \000 terminator if needed 898 | ** 899 | ** The following access routines are provided: 900 | ** 901 | ** _type() Return the datatype of the result. This is one of 902 | ** SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, 903 | ** or SQLITE_NULL. 904 | ** _blob() Return the value of a BLOB. 905 | ** _bytes() Return the number of bytes in a BLOB value or the number 906 | ** of bytes in a TEXT value represented as UTF-8. The \000 907 | ** terminator is included in the byte count for TEXT values. 908 | ** _bytes16() Return the number of bytes in a BLOB value or the number 909 | ** of bytes in a TEXT value represented as UTF-16. The \u0000 910 | ** terminator is included in the byte count for TEXT values. 911 | ** _double() Return a FLOAT value. 912 | ** _int() Return an INTEGER value in the host computer's native 913 | ** integer representation. This might be either a 32- or 64-bit 914 | ** integer depending on the host. 915 | ** _int64() Return an INTEGER value as a 64-bit signed integer. 916 | ** _text() Return the value as UTF-8 text. 917 | ** _text16() Return the value as UTF-16 text. 918 | */ 919 | const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); 920 | int sqlite3_column_bytes(sqlite3_stmt*, int iCol); 921 | int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); 922 | double sqlite3_column_double(sqlite3_stmt*, int iCol); 923 | int sqlite3_column_int(sqlite3_stmt*, int iCol); 924 | sqlite_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); 925 | const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); 926 | const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); 927 | int sqlite3_column_type(sqlite3_stmt*, int iCol); 928 | int sqlite3_column_numeric_type(sqlite3_stmt*, int iCol); 929 | 930 | /* 931 | ** The sqlite3_finalize() function is called to delete a compiled 932 | ** SQL statement obtained by a previous call to sqlite3_prepare() 933 | ** or sqlite3_prepare16(). If the statement was executed successfully, or 934 | ** not executed at all, then SQLITE_OK is returned. If execution of the 935 | ** statement failed then an error code is returned. 936 | ** 937 | ** This routine can be called at any point during the execution of the 938 | ** virtual machine. If the virtual machine has not completed execution 939 | ** when this routine is called, that is like encountering an error or 940 | ** an interrupt. (See sqlite3_interrupt().) Incomplete updates may be 941 | ** rolled back and transactions cancelled, depending on the circumstances, 942 | ** and the result code returned will be SQLITE_ABORT. 943 | */ 944 | int sqlite3_finalize(sqlite3_stmt *pStmt); 945 | 946 | /* 947 | ** The sqlite3_reset() function is called to reset a compiled SQL 948 | ** statement obtained by a previous call to sqlite3_prepare() or 949 | ** sqlite3_prepare16() back to it's initial state, ready to be re-executed. 950 | ** Any SQL statement variables that had values bound to them using 951 | ** the sqlite3_bind_*() API retain their values. 952 | */ 953 | int sqlite3_reset(sqlite3_stmt *pStmt); 954 | 955 | /* 956 | ** The following two functions are used to add user functions or aggregates 957 | ** implemented in C to the SQL langauge interpreted by SQLite. The 958 | ** difference only between the two is that the second parameter, the 959 | ** name of the (scalar) function or aggregate, is encoded in UTF-8 for 960 | ** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). 961 | ** 962 | ** The first argument is the database handle that the new function or 963 | ** aggregate is to be added to. If a single program uses more than one 964 | ** database handle internally, then user functions or aggregates must 965 | ** be added individually to each database handle with which they will be 966 | ** used. 967 | ** 968 | ** The third parameter is the number of arguments that the function or 969 | ** aggregate takes. If this parameter is negative, then the function or 970 | ** aggregate may take any number of arguments. 971 | ** 972 | ** The fourth parameter is one of SQLITE_UTF* values defined below, 973 | ** indicating the encoding that the function is most likely to handle 974 | ** values in. This does not change the behaviour of the programming 975 | ** interface. However, if two versions of the same function are registered 976 | ** with different encoding values, SQLite invokes the version likely to 977 | ** minimize conversions between text encodings. 978 | ** 979 | ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are 980 | ** pointers to user implemented C functions that implement the user 981 | ** function or aggregate. A scalar function requires an implementation of 982 | ** the xFunc callback only, NULL pointers should be passed as the xStep 983 | ** and xFinal parameters. An aggregate function requires an implementation 984 | ** of xStep and xFinal, but NULL should be passed for xFunc. To delete an 985 | ** existing user function or aggregate, pass NULL for all three function 986 | ** callback. Specifying an inconstent set of callback values, such as an 987 | ** xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is 988 | ** returned. 989 | */ 990 | int sqlite3_create_function( 991 | sqlite3 *, 992 | const char *zFunctionName, 993 | int nArg, 994 | int eTextRep, 995 | void*, 996 | void (*xFunc)(sqlite3_context*,int,sqlite3_value**), 997 | void (*xStep)(sqlite3_context*,int,sqlite3_value**), 998 | void (*xFinal)(sqlite3_context*) 999 | ); 1000 | int sqlite3_create_function16( 1001 | sqlite3*, 1002 | const void *zFunctionName, 1003 | int nArg, 1004 | int eTextRep, 1005 | void*, 1006 | void (*xFunc)(sqlite3_context*,int,sqlite3_value**), 1007 | void (*xStep)(sqlite3_context*,int,sqlite3_value**), 1008 | void (*xFinal)(sqlite3_context*) 1009 | ); 1010 | 1011 | /* 1012 | ** This function is deprecated. Do not use it. It continues to exist 1013 | ** so as not to break legacy code. But new code should avoid using it. 1014 | */ 1015 | int sqlite3_aggregate_count(sqlite3_context*); 1016 | 1017 | /* 1018 | ** The next group of routines returns information about parameters to 1019 | ** a user-defined function. Function implementations use these routines 1020 | ** to access their parameters. These routines are the same as the 1021 | ** sqlite3_column_* routines except that these routines take a single 1022 | ** sqlite3_value* pointer instead of an sqlite3_stmt* and an integer 1023 | ** column number. 1024 | */ 1025 | const void *sqlite3_value_blob(sqlite3_value*); 1026 | int sqlite3_value_bytes(sqlite3_value*); 1027 | int sqlite3_value_bytes16(sqlite3_value*); 1028 | double sqlite3_value_double(sqlite3_value*); 1029 | int sqlite3_value_int(sqlite3_value*); 1030 | sqlite_int64 sqlite3_value_int64(sqlite3_value*); 1031 | const unsigned char *sqlite3_value_text(sqlite3_value*); 1032 | const void *sqlite3_value_text16(sqlite3_value*); 1033 | const void *sqlite3_value_text16le(sqlite3_value*); 1034 | const void *sqlite3_value_text16be(sqlite3_value*); 1035 | int sqlite3_value_type(sqlite3_value*); 1036 | int sqlite3_value_numeric_type(sqlite3_value*); 1037 | 1038 | /* 1039 | ** Aggregate functions use the following routine to allocate 1040 | ** a structure for storing their state. The first time this routine 1041 | ** is called for a particular aggregate, a new structure of size nBytes 1042 | ** is allocated, zeroed, and returned. On subsequent calls (for the 1043 | ** same aggregate instance) the same buffer is returned. The implementation 1044 | ** of the aggregate can use the returned buffer to accumulate data. 1045 | ** 1046 | ** The buffer allocated is freed automatically by SQLite. 1047 | */ 1048 | void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); 1049 | 1050 | /* 1051 | ** The pUserData parameter to the sqlite3_create_function() 1052 | ** routine used to register user functions is available to 1053 | ** the implementation of the function using this call. 1054 | */ 1055 | void *sqlite3_user_data(sqlite3_context*); 1056 | 1057 | /* 1058 | ** The following two functions may be used by scalar user functions to 1059 | ** associate meta-data with argument values. If the same value is passed to 1060 | ** multiple invocations of the user-function during query execution, under 1061 | ** some circumstances the associated meta-data may be preserved. This may 1062 | ** be used, for example, to add a regular-expression matching scalar 1063 | ** function. The compiled version of the regular expression is stored as 1064 | ** meta-data associated with the SQL value passed as the regular expression 1065 | ** pattern. 1066 | ** 1067 | ** Calling sqlite3_get_auxdata() returns a pointer to the meta data 1068 | ** associated with the Nth argument value to the current user function 1069 | ** call, where N is the second parameter. If no meta-data has been set for 1070 | ** that value, then a NULL pointer is returned. 1071 | ** 1072 | ** The sqlite3_set_auxdata() is used to associate meta data with a user 1073 | ** function argument. The third parameter is a pointer to the meta data 1074 | ** to be associated with the Nth user function argument value. The fourth 1075 | ** parameter specifies a 'delete function' that will be called on the meta 1076 | ** data pointer to release it when it is no longer required. If the delete 1077 | ** function pointer is NULL, it is not invoked. 1078 | ** 1079 | ** In practice, meta-data is preserved between function calls for 1080 | ** expressions that are constant at compile time. This includes literal 1081 | ** values and SQL variables. 1082 | */ 1083 | void *sqlite3_get_auxdata(sqlite3_context*, int); 1084 | void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*)); 1085 | 1086 | 1087 | /* 1088 | ** These are special value for the destructor that is passed in as the 1089 | ** final argument to routines like sqlite3_result_blob(). If the destructor 1090 | ** argument is SQLITE_STATIC, it means that the content pointer is constant 1091 | ** and will never change. It does not need to be destroyed. The 1092 | ** SQLITE_TRANSIENT value means that the content will likely change in 1093 | ** the near future and that SQLite should make its own private copy of 1094 | ** the content before returning. 1095 | */ 1096 | #define SQLITE_STATIC ((void(*)(void *))0) 1097 | #define SQLITE_TRANSIENT ((void(*)(void *))-1) 1098 | 1099 | /* 1100 | ** User-defined functions invoke the following routines in order to 1101 | ** set their return value. 1102 | */ 1103 | void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); 1104 | void sqlite3_result_double(sqlite3_context*, double); 1105 | void sqlite3_result_error(sqlite3_context*, const char*, int); 1106 | void sqlite3_result_error16(sqlite3_context*, const void*, int); 1107 | void sqlite3_result_int(sqlite3_context*, int); 1108 | void sqlite3_result_int64(sqlite3_context*, sqlite_int64); 1109 | void sqlite3_result_null(sqlite3_context*); 1110 | void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); 1111 | void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); 1112 | void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); 1113 | void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); 1114 | void sqlite3_result_value(sqlite3_context*, sqlite3_value*); 1115 | 1116 | /* 1117 | ** These are the allowed values for the eTextRep argument to 1118 | ** sqlite3_create_collation and sqlite3_create_function. 1119 | */ 1120 | #define SQLITE_UTF8 1 1121 | #define SQLITE_UTF16LE 2 1122 | #define SQLITE_UTF16BE 3 1123 | #define SQLITE_UTF16 4 /* Use native byte order */ 1124 | #define SQLITE_ANY 5 /* sqlite3_create_function only */ 1125 | #define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ 1126 | 1127 | /* 1128 | ** These two functions are used to add new collation sequences to the 1129 | ** sqlite3 handle specified as the first argument. 1130 | ** 1131 | ** The name of the new collation sequence is specified as a UTF-8 string 1132 | ** for sqlite3_create_collation() and a UTF-16 string for 1133 | ** sqlite3_create_collation16(). In both cases the name is passed as the 1134 | ** second function argument. 1135 | ** 1136 | ** The third argument must be one of the constants SQLITE_UTF8, 1137 | ** SQLITE_UTF16LE or SQLITE_UTF16BE, indicating that the user-supplied 1138 | ** routine expects to be passed pointers to strings encoded using UTF-8, 1139 | ** UTF-16 little-endian or UTF-16 big-endian respectively. 1140 | ** 1141 | ** A pointer to the user supplied routine must be passed as the fifth 1142 | ** argument. If it is NULL, this is the same as deleting the collation 1143 | ** sequence (so that SQLite cannot call it anymore). Each time the user 1144 | ** supplied function is invoked, it is passed a copy of the void* passed as 1145 | ** the fourth argument to sqlite3_create_collation() or 1146 | ** sqlite3_create_collation16() as its first parameter. 1147 | ** 1148 | ** The remaining arguments to the user-supplied routine are two strings, 1149 | ** each represented by a [length, data] pair and encoded in the encoding 1150 | ** that was passed as the third argument when the collation sequence was 1151 | ** registered. The user routine should return negative, zero or positive if 1152 | ** the first string is less than, equal to, or greater than the second 1153 | ** string. i.e. (STRING1 - STRING2). 1154 | */ 1155 | int sqlite3_create_collation( 1156 | sqlite3*, 1157 | const char *zName, 1158 | int eTextRep, 1159 | void*, 1160 | int(*xCompare)(void*,int,const void*,int,const void*) 1161 | ); 1162 | int sqlite3_create_collation16( 1163 | sqlite3*, 1164 | const char *zName, 1165 | int eTextRep, 1166 | void*, 1167 | int(*xCompare)(void*,int,const void*,int,const void*) 1168 | ); 1169 | 1170 | /* 1171 | ** To avoid having to register all collation sequences before a database 1172 | ** can be used, a single callback function may be registered with the 1173 | ** database handle to be called whenever an undefined collation sequence is 1174 | ** required. 1175 | ** 1176 | ** If the function is registered using the sqlite3_collation_needed() API, 1177 | ** then it is passed the names of undefined collation sequences as strings 1178 | ** encoded in UTF-8. If sqlite3_collation_needed16() is used, the names 1179 | ** are passed as UTF-16 in machine native byte order. A call to either 1180 | ** function replaces any existing callback. 1181 | ** 1182 | ** When the user-function is invoked, the first argument passed is a copy 1183 | ** of the second argument to sqlite3_collation_needed() or 1184 | ** sqlite3_collation_needed16(). The second argument is the database 1185 | ** handle. The third argument is one of SQLITE_UTF8, SQLITE_UTF16BE or 1186 | ** SQLITE_UTF16LE, indicating the most desirable form of the collation 1187 | ** sequence function required. The fourth parameter is the name of the 1188 | ** required collation sequence. 1189 | ** 1190 | ** The collation sequence is returned to SQLite by a collation-needed 1191 | ** callback using the sqlite3_create_collation() or 1192 | ** sqlite3_create_collation16() APIs, described above. 1193 | */ 1194 | int sqlite3_collation_needed( 1195 | sqlite3*, 1196 | void*, 1197 | void(*)(void*,sqlite3*,int eTextRep,const char*) 1198 | ); 1199 | int sqlite3_collation_needed16( 1200 | sqlite3*, 1201 | void*, 1202 | void(*)(void*,sqlite3*,int eTextRep,const void*) 1203 | ); 1204 | 1205 | /* 1206 | ** Specify the key for an encrypted database. This routine should be 1207 | ** called right after sqlite3_open(). 1208 | ** 1209 | ** The code to implement this API is not available in the public release 1210 | ** of SQLite. 1211 | */ 1212 | int sqlite3_key( 1213 | sqlite3 *db, /* Database to be rekeyed */ 1214 | const void *pKey, int nKey /* The key */ 1215 | ); 1216 | 1217 | /* 1218 | ** Change the key on an open database. If the current database is not 1219 | ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the 1220 | ** database is decrypted. 1221 | ** 1222 | ** The code to implement this API is not available in the public release 1223 | ** of SQLite. 1224 | */ 1225 | int sqlite3_rekey( 1226 | sqlite3 *db, /* Database to be rekeyed */ 1227 | const void *pKey, int nKey /* The new key */ 1228 | ); 1229 | 1230 | /* 1231 | ** Sleep for a little while. The second parameter is the number of 1232 | ** miliseconds to sleep for. 1233 | ** 1234 | ** If the operating system does not support sleep requests with 1235 | ** milisecond time resolution, then the time will be rounded up to 1236 | ** the nearest second. The number of miliseconds of sleep actually 1237 | ** requested from the operating system is returned. 1238 | */ 1239 | int sqlite3_sleep(int); 1240 | 1241 | /* 1242 | ** Return TRUE (non-zero) if the statement supplied as an argument needs 1243 | ** to be recompiled. A statement needs to be recompiled whenever the 1244 | ** execution environment changes in a way that would alter the program 1245 | ** that sqlite3_prepare() generates. For example, if new functions or 1246 | ** collating sequences are registered or if an authorizer function is 1247 | ** added or changed. 1248 | ** 1249 | */ 1250 | int sqlite3_expired(sqlite3_stmt*); 1251 | 1252 | /* 1253 | ** Move all bindings from the first prepared statement over to the second. 1254 | ** This routine is useful, for example, if the first prepared statement 1255 | ** fails with an SQLITE_SCHEMA error. The same SQL can be prepared into 1256 | ** the second prepared statement then all of the bindings transfered over 1257 | ** to the second statement before the first statement is finalized. 1258 | */ 1259 | int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); 1260 | 1261 | /* 1262 | ** If the following global variable is made to point to a 1263 | ** string which is the name of a directory, then all temporary files 1264 | ** created by SQLite will be placed in that directory. If this variable 1265 | ** is NULL pointer, then SQLite does a search for an appropriate temporary 1266 | ** file directory. 1267 | ** 1268 | ** Once sqlite3_open() has been called, changing this variable will invalidate 1269 | ** the current temporary database, if any. 1270 | */ 1271 | extern char *sqlite3_temp_directory; 1272 | 1273 | /* 1274 | ** This function is called to recover from a malloc() failure that occured 1275 | ** within the SQLite library. Normally, after a single malloc() fails the 1276 | ** library refuses to function (all major calls return SQLITE_NOMEM). 1277 | ** This function restores the library state so that it can be used again. 1278 | ** 1279 | ** All existing statements (sqlite3_stmt pointers) must be finalized or 1280 | ** reset before this call is made. Otherwise, SQLITE_BUSY is returned. 1281 | ** If any in-memory databases are in use, either as a main or TEMP 1282 | ** database, SQLITE_ERROR is returned. In either of these cases, the 1283 | ** library is not reset and remains unusable. 1284 | ** 1285 | ** This function is *not* threadsafe. Calling this from within a threaded 1286 | ** application when threads other than the caller have used SQLite is 1287 | ** dangerous and will almost certainly result in malfunctions. 1288 | ** 1289 | ** This functionality can be omitted from a build by defining the 1290 | ** SQLITE_OMIT_GLOBALRECOVER at compile time. 1291 | */ 1292 | int sqlite3_global_recover(void); 1293 | 1294 | /* 1295 | ** Test to see whether or not the database connection is in autocommit 1296 | ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on 1297 | ** by default. Autocommit is disabled by a BEGIN statement and reenabled 1298 | ** by the next COMMIT or ROLLBACK. 1299 | */ 1300 | int sqlite3_get_autocommit(sqlite3*); 1301 | 1302 | /* 1303 | ** Return the sqlite3* database handle to which the prepared statement given 1304 | ** in the argument belongs. This is the same database handle that was 1305 | ** the first argument to the sqlite3_prepare() that was used to create 1306 | ** the statement in the first place. 1307 | */ 1308 | sqlite3 *sqlite3_db_handle(sqlite3_stmt*); 1309 | 1310 | /* 1311 | ** Register a callback function with the database connection identified by the 1312 | ** first argument to be invoked whenever a row is updated, inserted or deleted. 1313 | ** Any callback set by a previous call to this function for the same 1314 | ** database connection is overridden. 1315 | ** 1316 | ** The second argument is a pointer to the function to invoke when a 1317 | ** row is updated, inserted or deleted. The first argument to the callback is 1318 | ** a copy of the third argument to sqlite3_update_hook. The second callback 1319 | ** argument is one of SQLITE_INSERT, SQLITE_DELETE or SQLITE_UPDATE, depending 1320 | ** on the operation that caused the callback to be invoked. The third and 1321 | ** fourth arguments to the callback contain pointers to the database and 1322 | ** table name containing the affected row. The final callback parameter is 1323 | ** the rowid of the row. In the case of an update, this is the rowid after 1324 | ** the update takes place. 1325 | ** 1326 | ** The update hook is not invoked when internal system tables are 1327 | ** modified (i.e. sqlite_master and sqlite_sequence). 1328 | ** 1329 | ** If another function was previously registered, its pArg value is returned. 1330 | ** Otherwise NULL is returned. 1331 | */ 1332 | void *sqlite3_update_hook( 1333 | sqlite3*, 1334 | void(*)(void *,int ,char const *,char const *,sqlite_int64), 1335 | void* 1336 | ); 1337 | 1338 | /* 1339 | ** Register a callback to be invoked whenever a transaction is rolled 1340 | ** back. 1341 | ** 1342 | ** The new callback function overrides any existing rollback-hook 1343 | ** callback. If there was an existing callback, then it's pArg value 1344 | ** (the third argument to sqlite3_rollback_hook() when it was registered) 1345 | ** is returned. Otherwise, NULL is returned. 1346 | ** 1347 | ** For the purposes of this API, a transaction is said to have been 1348 | ** rolled back if an explicit "ROLLBACK" statement is executed, or 1349 | ** an error or constraint causes an implicit rollback to occur. The 1350 | ** callback is not invoked if a transaction is automatically rolled 1351 | ** back because the database connection is closed. 1352 | */ 1353 | void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); 1354 | 1355 | /* 1356 | ** This function is only available if the library is compiled without 1357 | ** the SQLITE_OMIT_SHARED_CACHE macro defined. It is used to enable or 1358 | ** disable (if the argument is true or false, respectively) the 1359 | ** "shared pager" feature. 1360 | */ 1361 | int sqlite3_enable_shared_cache(int); 1362 | 1363 | /* 1364 | ** Attempt to free N bytes of heap memory by deallocating non-essential 1365 | ** memory allocations held by the database library (example: memory 1366 | ** used to cache database pages to improve performance). 1367 | ** 1368 | ** This function is not a part of standard builds. It is only created 1369 | ** if SQLite is compiled with the SQLITE_ENABLE_MEMORY_MANAGEMENT macro. 1370 | */ 1371 | int sqlite3_release_memory(int); 1372 | 1373 | /* 1374 | ** Place a "soft" limit on the amount of heap memory that may be allocated by 1375 | ** SQLite within the current thread. If an internal allocation is requested 1376 | ** that would exceed the specified limit, sqlite3_release_memory() is invoked 1377 | ** one or more times to free up some space before the allocation is made. 1378 | ** 1379 | ** The limit is called "soft", because if sqlite3_release_memory() cannot free 1380 | ** sufficient memory to prevent the limit from being exceeded, the memory is 1381 | ** allocated anyway and the current operation proceeds. 1382 | ** 1383 | ** This function is only available if the library was compiled with the 1384 | ** SQLITE_ENABLE_MEMORY_MANAGEMENT option set. 1385 | ** memory-management has been enabled. 1386 | */ 1387 | void sqlite3_soft_heap_limit(int); 1388 | 1389 | /* 1390 | ** This routine makes sure that all thread-local storage has been 1391 | ** deallocated for the current thread. 1392 | ** 1393 | ** This routine is not technically necessary. All thread-local storage 1394 | ** will be automatically deallocated once memory-management and 1395 | ** shared-cache are disabled and the soft heap limit has been set 1396 | ** to zero. This routine is provided as a convenience for users who 1397 | ** want to make absolutely sure they have not forgotten something 1398 | ** prior to killing off a thread. 1399 | */ 1400 | void sqlite3_thread_cleanup(void); 1401 | 1402 | /* 1403 | ** Return meta information about a specific column of a specific database 1404 | ** table accessible using the connection handle passed as the first function 1405 | ** argument. 1406 | ** 1407 | ** The column is identified by the second, third and fourth parameters to 1408 | ** this function. The second parameter is either the name of the database 1409 | ** (i.e. "main", "temp" or an attached database) containing the specified 1410 | ** table or NULL. If it is NULL, then all attached databases are searched 1411 | ** for the table using the same algorithm as the database engine uses to 1412 | ** resolve unqualified table references. 1413 | ** 1414 | ** The third and fourth parameters to this function are the table and column 1415 | ** name of the desired column, respectively. Neither of these parameters 1416 | ** may be NULL. 1417 | ** 1418 | ** Meta information is returned by writing to the memory locations passed as 1419 | ** the 5th and subsequent parameters to this function. Any of these 1420 | ** arguments may be NULL, in which case the corresponding element of meta 1421 | ** information is ommitted. 1422 | ** 1423 | ** Parameter Output Type Description 1424 | ** ----------------------------------- 1425 | ** 1426 | ** 5th const char* Data type 1427 | ** 6th const char* Name of the default collation sequence 1428 | ** 7th int True if the column has a NOT NULL constraint 1429 | ** 8th int True if the column is part of the PRIMARY KEY 1430 | ** 9th int True if the column is AUTOINCREMENT 1431 | ** 1432 | ** 1433 | ** The memory pointed to by the character pointers returned for the 1434 | ** declaration type and collation sequence is valid only until the next 1435 | ** call to any sqlite API function. 1436 | ** 1437 | ** If the specified table is actually a view, then an error is returned. 1438 | ** 1439 | ** If the specified column is "rowid", "oid" or "_rowid_" and an 1440 | ** INTEGER PRIMARY KEY column has been explicitly declared, then the output 1441 | ** parameters are set for the explicitly declared column. If there is no 1442 | ** explicitly declared IPK column, then the output parameters are set as 1443 | ** follows: 1444 | ** 1445 | ** data type: "INTEGER" 1446 | ** collation sequence: "BINARY" 1447 | ** not null: 0 1448 | ** primary key: 1 1449 | ** auto increment: 0 1450 | ** 1451 | ** This function may load one or more schemas from database files. If an 1452 | ** error occurs during this process, or if the requested table or column 1453 | ** cannot be found, an SQLITE error code is returned and an error message 1454 | ** left in the database handle (to be retrieved using sqlite3_errmsg()). 1455 | ** 1456 | ** This API is only available if the library was compiled with the 1457 | ** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. 1458 | */ 1459 | int sqlite3_table_column_metadata( 1460 | sqlite3 *db, /* Connection handle */ 1461 | const char *zDbName, /* Database name or NULL */ 1462 | const char *zTableName, /* Table name */ 1463 | const char *zColumnName, /* Column name */ 1464 | char const **pzDataType, /* OUTPUT: Declared data type */ 1465 | char const **pzCollSeq, /* OUTPUT: Collation sequence name */ 1466 | int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ 1467 | int *pPrimaryKey, /* OUTPUT: True if column part of PK */ 1468 | int *pAutoinc /* OUTPUT: True if colums is auto-increment */ 1469 | ); 1470 | 1471 | /* 1472 | ** Undo the hack that converts floating point types to integer for 1473 | ** builds on processors without floating point support. 1474 | */ 1475 | #ifdef SQLITE_OMIT_FLOATING_POINT 1476 | # undef double 1477 | #endif 1478 | 1479 | #ifdef __cplusplus 1480 | } /* End of the 'extern "C"' block */ 1481 | #endif 1482 | #endif 1483 | -------------------------------------------------------------------------------- /SQLiteRecover/sqlite3.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/sqlite3.lib -------------------------------------------------------------------------------- /SQLiteRecover/stdafx.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/stdafx.cpp -------------------------------------------------------------------------------- /SQLiteRecover/stdafx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/stdafx.h -------------------------------------------------------------------------------- /SQLiteRecover/targetver.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dfrc-korea/SQLiteRecover/5a441a68c888e5f9d05fe7a25db5aa2b33e0dca9/SQLiteRecover/targetver.h --------------------------------------------------------------------------------