PDostatement ၏စွမ်းဆောင်ရည် bottleneck :: Fetchoboject ကို Big Data ကိုပြန်ပို့သောအခါ

PHP applications များကိုတီထွင်သောအခါဒေတာဘေ့စ်နှင့်အပြန်အလှန်ဆက်သွယ်ရန် PDO ကိုအသုံးပြုခြင်းသည်ဘုံအလေ့အကျင့်တစ်ခုဖြစ်လာသည်။ PDostatement :: Fetchobject: Fetchobject သည် query ကိုအရာဝတ်ထုများကိုအရာဝတ်ထုများကိုအရာဝတ်ထုများသို့အလွယ်တကူလုပ်ဆောင်နိုင်အောင်ပိုမိုလွယ်ကူစွာလုပ်ဆောင်နိုင်ရန်အတွက်အလွန်အသုံးဝင်သောလုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ သို့သော်ကျွန်ုပ်တို့သည်အချက်အလက်အမြောက်အများကိုလုပ်ဆောင်သောအခါ FetchObjection function သည်စွမ်းဆောင်ရည်မြှင့်တင်မှုများကိုကြုံတွေ့ရနိုင်သည်။ ဤဆောင်းပါးသည်ကြီးမားသောဒေတာများနှင့်ဆက်ဆံရာတွင် PDO ၏စွမ်းဆောင်ရည်ပြ problems နာများကိုဖြေရှင်းရန်အထောက်အကူပြုရန်အကောင်းဆုံးသောအကြံပြုချက်များကိုဆွေးနွေးပါမည်။

1 ။ ပြ problem နာခွဲခြမ်းစိတ်ဖြာ

PDostatement :: FetCobobject ,: Fetchobject , PHP Maps သည်ဒေတာဘေ့စ်တစ်ခုစီ၏အတန်းတစ်ခုစီသည်အရာဝတ်ထုတစ်ခုသို့ဖြစ်ပေါ်စေသည်။ ဤစစ်ဆင်ရေးသည်ကိစ္စရပ်အများစုတွင်ကောင်းမွန်စွာလုပ်ဆောင်နိုင်သော်လည်းအချက်အလက်အတွဲသည်အလွန်ကြီးမားသည့်အခါအောက်ပါပြ problems နာများပေါ်ပေါက်လာလိမ့်မည်။

• Memory High Memory Footprint : အချိန်ကုန်ခံပြီးတိုင်း ဟုခေါ်သောအခါတိုင်းအရာဝတ်ထုတစ်ခုစားသုံးသည်။

• နှေးကွေးသောတုံ့ပြန်မှု - ဒေတာအစုများအောက်တွင်အတန်းဖြင့်အတန်းများဖတ်ခြင်းနှင့်အရာဝတ်ထုများသို့စာဖတ်ခြင်းသည်အလွန်နှေးကွေးနိုင်သည်။

• ဒေတာဘေ့စ်ဆက်သွယ်မှုသည်အချိန်ကြာမြင့်စွာတက်သည် ။ အကယ်. စုံစမ်းမှုကိုကောင်းမွန်စွာအသုံးမပြုပါကကြာမြင့်စွာကွပ်မျက်ခြင်းအချိန်သည်တောင်းဆိုမှုကိုအချိန်ယူစေနိုင်သည်။

စွမ်းဆောင်ရည်ကိုပိုမိုကောင်းမွန်စေရန်ဤအခက်အခဲများကိုရှောင်ရှားရန်ခြေလှမ်းအချို့ကိုကျွန်ုပ်တို့ပြုလုပ်နိုင်ပြီးဤနေရာတွင်ဘုံဖြေရှင်းချက်အနည်းငယ်သာရှိသည်။

2 ။ ဖြေရှင်းချက်ကိုပိုကောင်းအောင်လုပ်ပါ

PDO :: FETT_OBJ အစား PDO :: FETT_AST_AST_ASSOC ကိုအသုံးပြုပါ

PDostatement :: FetchOccokjects ည့်သည် ဘာသာပြောင်းဝင်လာခြင်းကအရာဝတ်ထုတစ်ခုသို့ရလဒ်များ။ ဤနည်းလမ်းသည်အရာဝတ်ထု -orient-oriented programing ပုံစံနှင့်အညီပိုမိုများပြားသော်လည်းကြီးမားသောအချက်အလက်များနှင့်ဆက်ဆံရာတွင်အရာဝတ်ထုအမြောက်အများကိုထုတ်လုပ်ခြင်းသည်မလိုအပ်သော overhead ကိုဖြစ်ပေါ်စေနိုင်သည်။ အကယ်. ၎င်းသည်ဒေတာဘေ့စ်နယ်ပယ်ကိုကြည့်ရှုရန်သာလျှင် PDO :: Fetter_assoc ကိုအသုံးပြုခြင်းသည်ပိုမိုထိရောက်နိုင်သည်။ ရလဒ်တစ်ခုချင်းစီကိုအရာဝတ်ထုတစ်ခုထက် Associative Array တစ်ခုအဖြစ်ပြန်ပေးသည်။

နမူနာကုဒ်:

 <?php
// ဖန်တီး PDO နမူနာ
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');

// တစ် ဦး စုံစမ်းမှု execute
$stmt = $pdo->query('SELECT * FROM large_table');

// အသုံးပြု FETCH_ASSOC ပြန်လည်နေရာချ FETCH_OBJ
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    // အချက်အလက်များကိုထုတ်ယူခြင်း
    echo $row['column_name'] . "\n";
}
?>

ဤနည်းအားဖြင့်ကျွန်ုပ်တို့သည်ဒေတာတစ်ခုစီအတွက်အရာဝတ်ထုတစ်ခုကိုဖန်တီးခြင်းကိုရှာဖွေခြင်းကိုရှောင်ကြဉ်ခြင်းကြောင့်မှတ်ဉာဏ်အသုံးပြုမှုကိုလျော့နည်းစေသည်။

2.2 ဒေတာများကိုအသုတ်တွင်ရှာဖွေရန် ကန့်သတ်ချက်ကို အသုံးပြုပါ

အကယ်. သင်သည်အချက်အလက်အမြောက်အများကိုတစ်ချိန်တည်းတွင်မေးမြန်းပါကဒေတာဘေ့စ်နှင့်လျှောက်လွှာ၏စွမ်းဆောင်ရည်အပေါ်များစွာအကျိုးသက်ရောက်နိုင်သည်။ ထိရောက်သောချဉ်းကပ်နည်းသည်အချက်အလက်များကိုအသုတ်တွင်ရှာဖွေရန် ကန့်သတ်ချက်ကို အသုံးပြုရန်ဖြစ်သည်။ ဤနည်းလမ်းသည်ကြီးမားသောဒေတာများကိုသေးငယ်သောအသုတ်များအဖြစ်ခွဲထားနိုင်သည်။

နမူနာကုဒ်:

 <?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');
$batchSize = 1000;  // တစ်ခုချင်းစီကိုစုံစမ်းမှု1000အချက်များ
$offset = 0;

do {
    $stmt = $pdo->prepare('SELECT * FROM large_table LIMIT :limit OFFSET :offset');
    $stmt->bindValue(':limit', $batchSize, PDO::PARAM_INT);
    $stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
    $stmt->execute();

    // ဒေတာတစ်ခုချင်းစီကိုအသုတ်
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        echo $row['column_name'] . "\n";
    }

    $offset += $batchSize;
} while ($stmt->rowCount() > 0);  // နေဆဲဒေတာရှိလျှင်，ဆက်မေးနေအောင်
?>

ဤနည်းအားဖြင့်စနစ်သည်တစ်ချိန်တည်းတွင်ဒေတာအနည်းငယ်ကိုသာအသုံးပြုသည်။ ၎င်းသည်မှတ်ဥာဏ်ဖိအားကိုသိသိသာသာလျှော့ချနိုင်သည်။

2.3 PDO :: Fetter_bound ကိုအသုံးပြုပြီး 2.3 binding variable တွေကို binding

စွမ်းဆောင်ရည်ကိုတိုးတက်စေရန်နောက်ထပ်နည်းလမ်းမှာ PDO :: FETL_BOUDE ကို အသုံးပြုရန်ဖြစ်သည်။ ၎င်းသည်အထူးသဖြင့်ဒေတာအသံအ တိုး အကျယ် အလွန်ကြီးသောအခါ,

နမူနာကုဒ်:

 <?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');

$stmt = $pdo->query('SELECT id, name FROM large_table');
$stmt->bindColumn('id', $id);
$stmt->bindColumn('name', $name);

while ($stmt->fetch(PDO::FETCH_BOUND)) {
    echo "ID: $id, Name: $name\n";
}
?>

ဤနည်းအားဖြင့် အချိန်ကုန်ခံပြီး အချိန်တိုင်းဟုခေါ်သည့်အခါ ID နှင့် Name ၏တန်ဖိုးများသည် arrays သို့မဟုတ်အရာဝတ်ထုများကိုဖန်တီးရန်နောက်ထပ်မှတ်ဉာဏ် overhead မပါဘဲ variable များကို $ ID နှင့် $ အမည်ရှိသည့် အတွက်တိုက်ရိုက်ချည်နှောင်ထားသည်။

2.4 ensentent ဆက်သွယ်မှုများနှင့်ဆက်သွယ်မှုရေကန်များကိုအသုံးပြုခြင်း

ကြိမ်နှုန်းနှင့်ကြီးမားသောဒေတာလုပ်ငန်းများအတွက်ဒေတာဘေ့စ်ဆက်သွယ်မှုများ၏ overhead သည်လျစ်လျူရှုမရနိုင်သောပြ issue နာတစ်ခုဖြစ်သည်။ ဆက်နွယ်မှုတည်ဆောက်ခြင်းနှင့်ဖျက်ဆီးခြင်းကြောင့်ဖြစ်ရတဲ့အချိန်စားသုံးမှုကိုလျှော့ချရန်အမြဲတမ်းဆက်သွယ်မှုများသို့မဟုတ် connection pointering နည်းစနစ်များကိုအသုံးပြုရန်စဉ်းစားနိုင်သည်။

 <?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password', [
    PDO::ATTR_PERSISTENT => true,  // မြဲ connection များကို enable
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]);

// နောက်ဆက်တွဲဒေတာဘေ့စစစ်ဆင်ရေး
?>

ဆက်နွယ်သောဆက်သွယ်မှုများကိုတောင်းဆိုမှုများစွာကို ဖြတ်. ပြန်လည်အသုံးပြုခြင်း,

3 ။ အကျဉ်းချုပ်

PDostatement :: FetchObjection function ကိုအသုံးပြုသောအခါကျွန်ုပ်တို့သည်စွမ်းဆောင်ရည်ကိုပိုမိုကောင်းမွန်အောင်ပြုလုပ်နိုင်သည်။

• PDO :: FETLE_AST_AST_AST_ABJ အစား PDO :: FETT_OBJ အစား PDO :: FETT_OBJ အစား PDE :: BoBJ အစားအသုံးပြုပါ။

• Query တစ်ခုစီအတွက်အချက်အလက်ပမာဏကိုလျှော့ချရန်အစုထဲတွင်အချက်အလက်များကိုရှာဖွေမေးမြန်းခြင်း။

• PDO :: FETL_Bound ကို သုံး. query ကို variable ကိုတိုက်ရိုက်ချည်နှောင်ရန်။

• ဒေတာဘေ့စ် connection overhead ကိုလျှော့ချရန်မြဲမြဲ connection များကို enable လုပ်ပါ။

ဤ optimization နည်းလမ်းများမှတစ်ဆင့်ကြီးမားသောဒေတာရှာဖွေမှုကိုထိရောက်စွာတိုးတက်အောင်လုပ်နိုင်သည့်စွမ်းဆောင်ရည်ကိုထိထိရောက်ရောက်တိုးတက်အောင်လုပ်နိုင်သည်, မှတ်ဉာဏ်အသုံးပြုမှုကိုလျှော့ချနိုင်ပြီးတုံ့ပြန်မှုမြန်နှုန်းကိုတိုးတက်စေနိုင်သည်။ စွမ်းဆောင်ရည်မြှင့်တင်မှုများကိုသင်ကြုံတွေ့ရပါကသင်၏ဒေတာဘေ့စ်လည်ပတ်မှုများကိုပိုမိုကောင်းမွန်စေရန်ဤနည်းလမ်းများကိုကြိုးစားကြည့်ပါ။