SQLite ප්‍රශස්ත කිරීම උපක්‍රමශීලී ය. සී යෙදුමක තොග ඇතුළත් කිරීමේ ක්‍රියාකාරිත්වය තත්පරයට ඇතුළු කිරීම් 85 සිට තත්පරයට ඇතුළු කිරීම් 96,000 දක්වා වෙනස් විය හැකිය!
පසුබිම: අපි ඩෙස්ක්ටොප් යෙදුමක කොටසක් ලෙස SQLite භාවිතා කරමු. යෙදුම ආරම්භ කරන විට වැඩිදුර සැකසීම සඳහා එක්ස්එම්එල් ලිපිගොනු තුළ ගබඩා කර ඇති වින්‍යාස දත්ත විශාල ප්‍රමාණයක් අප සතුව ඇත. SQLite මෙම තත්වයට වඩාත් සුදුසු වන්නේ එය වේගවත් බැවින් එයට විශේෂිත වින්‍යාසයක් අවශ්‍ය නොවන අතර දත්ත සමුදාය තැටියේ තනි ගොනුවක් ලෙස ගබඩා කර ඇති බැවිනි.
තාර්කිකත්වය: මුලදී මා දුටු රංගනය ගැන මම කලකිරුණා. දත්ත සමුදාය වින්‍යාසගත කර ඇති ආකාරය සහ ඔබ ඒපීඅයි භාවිතා කරන්නේ කෙසේද යන්න මත පදනම්ව SQLite හි ක්‍රියාකාරීත්වය සැලකිය යුතු ලෙස වෙනස් විය හැකිය (තොග ඇතුළත් කිරීම් සහ තේරීම් සඳහා). සියලු විකල්ප සහ ශිල්පීය ක්‍රම මොනවාදැයි සොයා ගැනීම සුළුපටු කාරණයක් නොවූ අතර, එම විමර්ශනවලම කරදර අනෙක් අය බේරා ගැනීම සඳහා ස්ටැක් පිටාර ගැලීමේ පා readers කයන් සමඟ ප්‍රති results ල බෙදා ගැනීම සඳහා මෙම ප්‍රජා විකී ප්‍රවේශය නිර්මාණය කිරීම විචක්ෂණශීලී යැයි මම සිතුවෙමි.
අත්හදා බැලීම: සාමාන්‍ය අර්ථයෙන් කාර්ය සාධන ඉඟි ගැන කතා කරනවා වෙනුවට (එනම් "ගනුදෙනුවක් භාවිතා කරන්න!" ), මම සිතුවේ සී කේතයක් ලිවීම සහ විවිධ විකල්පවල බලපෑම මැනීම . අපි සරල දත්ත කිහිපයක් සමඟ ආරම්භ කරන්නෙමු:
- ටොරොන්ටෝ නගරය සඳහා සම්පූර්ණ සංක්‍රාන්ති කාලසටහනේ 28 MB TAB වෙන් කරන ලද පෙළ ගොනුවක් (දළ වශයෙන් වාර්තා 865,000)
- මගේ පරීක්ෂණ යන්ත්‍රය වින්ඩෝස් එක්ස්පී ධාවනය වන 3.60 GHz P4 ය.
- කේතය විෂුවල් සී ++ 2005 සමඟ "මුදා හැරීම" ලෙස "පූර්ණ ප්‍රශස්තිකරණය" (/ ඔක්ස්) සහ ෆේවර් වේගවත් කේතය (/ ඔට්) සමඟ සම්පාදනය කර ඇත.
- මගේ පරීක්ෂණ යෙදුමට කෙලින්ම සම්පාදනය කරන ලද SQLite "Amalgamation" මම භාවිතා කරමි. මා සතුව ඇති SQLite අනුවාදය ටිකක් පැරණි (3.6.7), නමුත් මෙම ප්‍රති results ල නවතම නිකුතුව සමඟ සැසඳිය හැකි යැයි මම සැක කරමි (කරුණාකර ඔබ වෙනත් ආකාරයකින් සිතන්නේ නම් අදහස් දක්වන්න).
අපි කේත කිහිපයක් ලියමු!
කේතය: සරල සී වැඩසටහනක් මඟින් පෙළ ගොනුව රේඛීයව කියවන අතර, එම නූල අගයන් වලට බෙදී දත්ත SQLite දත්ත ගබඩාවකට ඇතුළත් කරයි. කේතයේ මෙම "මූලික" අනුවාදයේ, දත්ත සමුදාය නිර්මාණය කර ඇත, නමුත් අපි ඇත්ත වශයෙන්ම දත්ත ඇතුළත් නොකරමු:
/*************************************************************
Baseline code to experiment with SQLite performance.
Input data is a 28 MB TAB-delimited text file of the
complete Toronto Transit System schedule/route info
from http://www.toronto.ca/open/datasets/ttc-routes/
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "sqlite3.h"
#define INPUTDATA "C:\\TTC_schedule_scheduleitem_10-27-2009.txt"
#define DATABASE "c:\\TTC_schedule_scheduleitem_10-27-2009.sqlite"
#define TABLE "CREATE TABLE IF NOT EXISTS TTC (id INTEGER PRIMARY KEY, Route_ID TEXT, Branch_Code TEXT, Version INTEGER, Stop INTEGER, Vehicle_Index INTEGER, Day Integer, Time TEXT)"
#define BUFFER_SIZE 256
int main(int argc, char **argv) {
sqlite3 * db;
sqlite3_stmt * stmt;
char * sErrMsg = 0;
char * tail = 0;
int nRetCode;
int n = 0;
clock_t cStartClock;
FILE * pFile;
char sInputBuf [BUFFER_SIZE] = "\0";
char * sRT = 0; /* Route */
char * sBR = 0; /* Branch */
char * sVR = 0; /* Version */
char * sST = 0; /* Stop Number */
char * sVI = 0; /* Vehicle */
char * sDT = 0; /* Date */
char * sTM = 0; /* Time */
char sSQL [BUFFER_SIZE] = "\0";
/*********************************************/
/* Open the Database and create the Schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
/*********************************************/
/* Open input file and import into Database*/
cStartClock = clock();
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
/* ACTUAL INSERT WILL GO HERE */
n++;
}
fclose (pFile);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_close(db);
return 0;
}
"පාලනය"
කේතය පවතින ආකාරයට ක්‍රියාත්මක කිරීම ඇත්ත වශයෙන්ම කිසිදු දත්ත සමුදායක් සිදු නොකරයි, නමුත් එය අමු සී ගොනුව I / O සහ නූල් සැකසුම් මෙහෙයුම් කොතරම් වේගවත්ද යන්න පිළිබඳ අදහසක් ලබා දෙනු ඇත.
තත්පර 0.94 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
මහා! අපට තත්පරයට ඇතුළු කිරීම් 920,000 ක් කළ හැකිය, අප සැබවින්ම කිසිදු ඇතුළත් කිරීමක් නොකරන්නේ නම් :-)
"නරකම-සිද්ධි-සිදුවීම"
අපි ගොනුවෙන් කියවන ලද අගයන් භාවිතා කරමින් SQL නූල ජනනය කර sqlite3_exec භාවිතා කරමින් එම SQL මෙහෙයුම ක්‍රියාත්මක කරන්නෙමු:
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, '%s', '%s', '%s', '%s', '%s', '%s', '%s')", sRT, sBR, sVR, sST, sVI, sDT, sTM);
sqlite3_exec(db, sSQL, NULL, NULL, &sErrMsg);
මෙය මන්දගාමී වනු ඇත, මන්ද සෑම ඇතුල් කිරීමක් සඳහාම SQL VDBE කේතයට සම්පාදනය වන අතර සෑම ඇතුළු කිරීමක්ම තමන්ගේම ගනුදෙනුවකදී සිදුවනු ඇත. කෙතරම් මන්දගාමීද?
තත්පර 9933.61 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
අහෝ! පැය 2 යි විනාඩි 45 යි! එය තත්පරයට ඇතුළු කිරීම් 85 ක් පමණි.
ගනුදෙනුවක් භාවිතා කිරීම
පෙරනිමියෙන්, SQLite අද්විතීය ගනුදෙනුවක් තුළ සෑම INSERT / UPDATE ප්‍රකාශයක්ම ඇගයීමට ලක් කරයි. ඇතුළු කිරීම් විශාල සංඛ්‍යාවක් සිදු කරන්නේ නම්, ගනුදෙනුවකදී ඔබේ ක්‍රියාකාරිත්වය එතීම සුදුසුය:
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
...
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
තත්පර 38.03 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
එය වඩා හොඳය. අපගේ සියලුම ඇතුළත් කිරීම් තනි ගනුදෙනුවකින් ඔතා අපගේ කාර්ය සාධනය තත්පරයට ඇතුළු කිරීම් 23,000 දක්වා වැඩි දියුණු කළේය.
සකස් කළ ප්රකාශයක් භාවිතා කිරීම
ගනුදෙනුවක් භාවිතා කිරීම විශාල දියුණුවක් විය, නමුත් සෑම ඇතුල් කිරීමක් සඳහාම SQL ප්‍රකාශය නැවත සකස් කිරීම අප එකම SQL නැවත නැවත භාවිතා කරන්නේ නම් තේරුමක් නැත. sqlite3_prepare_v2අපගේ SQL ප්‍රකාශය එක් වරක් සම්පාදනය කර අපගේ පරාමිතීන් එම ප්‍රකාශයට බැඳ තබමු sqlite3_bind_text:
/* Open input file and import into the database */
cStartClock = clock();
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, @RT, @BR, @VR, @ST, @VI, @DT, @TM)");
sqlite3_prepare_v2(db, sSQL, BUFFER_SIZE, &stmt, &tail);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
sqlite3_bind_text(stmt, 1, sRT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, sBR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, sVR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, sST, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 5, sVI, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 6, sDT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 7, sTM, -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
n++;
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
තත්පර 16.27 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
හොඳයි! (කතා කරන්න අමතක කරන්න එපා ටිකක් වැඩි කේතය තියෙනවා sqlite3_clear_bindingsසහ sqlite3_reset), නමුත් අපි වඩා වැඩි අපේ කාර්ය සාධනය දෙගුණ තියෙනවා තත්පරයට 53,000 රැසක්.
ප්‍රග්මා සමමුහුර්ත = අක්‍රියයි
පෙරනිමියෙන්, OSite මට්ටමේ ලිවීමේ විධානයක් නිකුත් කිරීමෙන් පසු SQLite විරාමයක් ලබා දෙනු ඇත. දත්ත තැටියට ලියා ඇති බවට මෙය සහතික කරයි. සැකසීමෙන් synchronous = OFF, අපි SQLite ට උපදෙස් දෙන්නේ දත්ත ලිවීම සඳහා මෙහෙයුම් පද්ධතියට භාර දී ඉදිරියට යන්න. තැටියට දත්ත ලිවීමට පෙර පරිගණකය ව්‍යසනකාරී බිඳවැටීමකට (හෝ විදුලිය ඇනහිටීමට) ලක් වුවහොත් දත්ත සමුදා ගොනුව දූෂිත වීමට අවස්ථාවක් තිබේ:
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
තත්පර 12.41 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
වැඩිදියුණු කිරීම් දැන් කුඩා වන නමුත් අපි තත්පරයට ඇතුළු කිරීම් 69,600 ක් දක්වා ඉහළ නංවන්නෙමු.
PRAGMA magazine_mode = මතකය
ඇගයීමෙන් රෝල්බැක් ජර්නලය මතකයේ ගබඩා කිරීම සලකා බලන්න PRAGMA journal_mode = MEMORY. ඔබේ ගනුදෙනුව වේගවත් වනු ඇත, නමුත් ගනුදෙනුවක් අතරතුරදී ඔබට බලය අහිමි වුවහොත් හෝ ඔබේ වැඩසටහන බිඳ වැටුණහොත් ඔබේ දත්ත සමුදාය අර්ධ වශයෙන් සම්පුර්ණ කරන ලද ගනුදෙනුවක් සමඟ දූෂිත තත්වයකට පත්විය හැකිය:
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
තත්පර 13.50 කින් වාර්තා 864913 ක් ආනයනය කරන ලදි
තත්පරයට ඇතුළු කිරීම් 64,000 ක පෙර ප්‍රශස්තිකරණයට වඩා ටිකක් මන්දගාමී වේ .
PRAGMA synchronous = OFF සහ PRAGMA magazine_mode = MEMORY
පෙර ප්‍රශස්තිකරණ දෙක ඒකාබද්ධ කරමු. එය තව ටිකක් අවදානම් සහගතයි (බිඳවැටීමකදී), නමුත් අපි දත්ත ආනයනය කරනවා (බැංකුවක් පවත්වාගෙන යන්නේ නැත):
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
තත්පර 12.00 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
නියමයි! අපට තත්පරයට ඇතුළු කිරීම් 72,000 ක් කළ හැකිය.
මතක මතක දත්ත ගබඩාවක් භාවිතා කිරීම
කික් සඳහා පමණක්, අපි පෙර පැවති සියලු ප්‍රශස්තිකරණයන් මත ගොඩනගා දත්ත සමුදා ගොනු නාමය නැවත අර්ථ දක්වමු, එවිට අපි සම්පූර්ණයෙන්ම RAM හි වැඩ කරමු:
#define DATABASE ":memory:"තත්පර 10.94 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
අපගේ දත්ත සමුදාය RAM තුළ ගබඩා කිරීම සුපිරි ප්‍රායෝගික නොවේ, නමුත් අපට තත්පරයට ඇතුළු කිරීම් 79,000 ක් සිදු කළ හැකි වීම පුදුම සහගතය.
සී කේතය ප්‍රතිනිර්මාණය කිරීම
විශේෂයෙන් SQLite වැඩිදියුණු කිරීමක් නොවුනත් char*, whileලූපයේ අමතර පැවරුම් මෙහෙයුම් වලට මම කැමති නැත . ප්‍රතිදානය strtok()කෙලින්ම sqlite3_bind_text()සම්ප්‍රේෂණය කිරීමට එම කේතය ඉක්මනින් ප්‍රතිනිර්මාණය කරමු, සහ අප වෙනුවෙන් දේවල් වේගවත් කිරීමට සම්පාදකයාට ඉඩ දෙන්න:
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sqlite3_bind_text(stmt, 1, strtok (sInputBuf, "\t"), -1, SQLITE_TRANSIENT); /* Get Route */
sqlite3_bind_text(stmt, 2, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Branch */
sqlite3_bind_text(stmt, 3, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Version */
sqlite3_bind_text(stmt, 4, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Stop Number */
sqlite3_bind_text(stmt, 5, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Vehicle */
sqlite3_bind_text(stmt, 6, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Date */
sqlite3_bind_text(stmt, 7, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Time */
sqlite3_step(stmt); /* Execute the SQL Statement */
sqlite3_clear_bindings(stmt); /* Clear bindings */
sqlite3_reset(stmt); /* Reset VDBE */
n++;
}
fclose (pFile);
සටහන: අපි නැවත සත්‍ය දත්ත සමුදා ගොනුවක් භාවිතා කිරීමට පැමිණ සිටිමු. මතකයේ ඇති දත්ත සමුදායන් වේගවත් නමුත් අවශ්‍යයෙන්ම ප්‍රායෝගික නොවේ
තත්පර 8.94 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
අපගේ පරාමිති බන්ධනයේදී භාවිතා කරන නූල් සැකසුම් කේතයට සුළු වශයෙන් ප්‍රතිනිර්මාණය කිරීමෙන් තත්පරයට ඇතුළු කිරීම් 96,700 ක් සිදු කිරීමට අපට ඉඩ ලබා දී ඇත . මම හිතන්නේ මෙය ඉතා වේගවත් යැයි කීම ආරක්ෂිතයි . අපි වෙනත් විචල්‍යයන් වෙනස් කිරීමට පටන් ගන්නා විට (එනම් පිටු ප්‍රමාණය, දර්ශක නිර්මාණය, ආදිය) මෙය අපගේ මිණුම් ලකුණ වනු ඇත.
සාරාංශය (මෙතෙක්)
මම හිතනවා ඔයා තාමත් මාත් එක්ක ඉන්නවා කියලා! අප මෙම මාර්ගයෙන් ආරම්භ වීමට හේතුව SQLite සමඟ තොග ඇතුළත් කිරීමේ කාර්ය සාධනය එතරම් වෙනස් වන අතර අපගේ ක්‍රියාකාරිත්වය වේගවත් කිරීම සඳහා කළ යුතු වෙනස්කම් මොනවාද යන්න සැමවිටම පැහැදිලි නැත. එකම සම්පාදක (සහ සම්පාදක විකල්ප) භාවිතා කරමින්, SQLite හි එකම අනුවාදය සහ අප විසින් අපගේ කේතය සහ SQLite භාවිතය ප්‍රශස්තිකරණය කර ඇති අතර තත්පරයට ඇතුළු කිරීම් 85 ක් වැනි නරකම අවස්ථාවක සිට තත්පරයට ඇතුළු කිරීම් 96,000 ක් දක්වා ඉහළ යයි!
INDEX සාදන්න ඉන්පසු INSERT එදිරිව INSERT පසුව INDEX සාදන්න
SELECTකාර්ය සාධනය මැනීමට පෙර , අපි දර්ශක නිර්මාණය කරන බව අපි දනිමු. පහත දැක්වෙන එක් පිළිතුරකින් යෝජනා කර ඇත්තේ තොග ඇතුළත් කිරීම් සිදු කරන විට, දත්ත ඇතුළත් කිරීමෙන් පසුව දර්ශකය නිර්මාණය කිරීම වේගවත් බවය (දර්ශකය නිර්මාණය කිරීමට හා පසුව දත්ත ඇතුල් කිරීමට වඩා වෙනස්ව). අපි උත්සාහ කරමු:
දර්ශකය සාදන්න ඉන්පසු දත්ත ඇතුල් කරන්න
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
...
තත්පර 18.13 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
දත්ත ඇතුළු කර දර්ශකය සාදන්න
...
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
තත්පර 13.66 කින් වාර්තා 864913 ක් ආනයනය කර ඇත
අපේක්ෂා කළ පරිදි, එක් තීරුවක් සුචිගත කර ඇත්නම් තොග ඇතුළත් කිරීම් මන්දගාමී වේ, නමුත් දත්ත ඇතුළත් කිරීමෙන් පසුව දර්ශකය නිර්මාණය කළ හොත් එය වෙනසක් ඇති කරයි. අපගේ දර්ශක රහිත පදනම තත්පරයට ඇතුළු කිරීම් 96,000 කි. පළමුවෙන්ම දර්ශකය නිර්මාණය කිරීමෙන් පසුව දත්ත ඇතුළත් කිරීමෙන් තත්පරයට ඇතුළු කිරීම් 47,700 ක් ලබා දෙන අතර දත්ත මුලින්ම ඇතුළත් කිරීමෙන් පසුව දර්ශකය නිර්මාණය කිරීමෙන් තත්පරයට ඇතුළත් කිරීම් 63,300 ක් ලැබේ.
වෙනත් අවස්ථා සඳහා උත්සාහ කිරීම සඳහා මම සතුටින් යෝජනා ගන්නෙමි ... තවද SELECT විමසුම් සඳහා සමාන දත්ත සම්පාදනය කරමි.
sqlite3_clear_bindings(stmt);තිබේද? ප්‍රමාණවත් විය යුතු සෑම අවස්ථාවකම ඔබ බන්ධන සකසා ඇත: පළමු වරට sqlite3_step () ඇමතීමට පෙර හෝ sqlite3_reset () පසු වහාම, පරාමිතීන්ට අගයන් ඇමිණීම සඳහා යෙදුමට sqlite3_bind () අතුරුමුහුණතක් කැඳවිය හැකිය. Sqlite3_bind () සඳහා වන සෑම ඇමතුමක්ම එකම පරාමිතියක පෙර බන්ධන අභිබවා යයි (බලන්න: sqlite.org/cintro.html ). එම ශ්‍රිතය සඳහා ලේඛනයේ කිසිවක් නැත, ඔබ එය ඇමතිය යුතු යැයි කියනු ලැබේ.
feof()ඔබගේ ආදාන ලූපය අවසන් කිරීම පාලනය කිරීමට භාවිතා නොකරන්න . ලබා දුන් ප්‍රති result ලය භාවිතා කරන්න fgets(). stackoverflow.com/a/15485689/827263