ดึงข้อมูลจากเว็บเก่ารอบใหม่ แล้วของที่แก้มือไว้กลับไปเป็นแบบเดิม
คำสั่ง import ที่รันซ้ำได้โดยไม่เกิดแถวซ้ำ ยังไม่ได้แปลว่ามันไม่ทับงานของคน ตราบใดที่ไม่มีใครบอก importer ว่าช่องไหนเป็นของใคร ทุกรอบ sync คือการย้อนเวลาเว็บกลับไปวันที่ยังไม่มีใครแก้อะไร
สรุปใน 1 นาที
- อาการ/ปัญหา
- import ข้อมูลจากเว็บเก่ารอบใหม่ทับของที่แก้มือไว้ เช่นรูปปกและคำที่เจ้าของสั่งแก้
- ใครควรอ่าน
- คนดูแลเว็บใหม่ที่ยังต้อง import เนื้อหาจากเว็บเก่าเป็นรอบๆ
- ทางแก้แบบสั้น
- แบ่งความเป็นเจ้าของช่องเป็น 3 ชั้น ล็อกช่องที่คนแก้ ใช้ override ทับท้ายสุด และรันกฎหลัง import ทุกรอบ
พอดีผมรับงานย้ายเว็บเก่าของลูกค้ารายหนึ่งมาอยู่บนเว็บใหม่ที่เขียนด้วย Laravel เนื้อหาทั้งหมดเป็นของเจ้าของเว็บเอง เจ้าของเป็นคนสั่งให้ย้ายและเปิดทางให้เอง ไม่ได้ไปเอาของใครมา ปัญหาคือช่วงเปลี่ยนผ่านเว็บเก่ายังมีทีมงานเข้าไปอัปเดตอยู่ ผมเลยต้อง import ซ้ำเป็นรอบ ๆ แล้วภายในสัปดาห์เดียวก็เจอว่าของที่แก้มือไว้บนเว็บใหม่ กลับไปเป็นแบบเดิมห้าเรื่องติดกัน
ชื่อธุรกิจ โดเมน รหัสรายการ และชื่อคน ผมเปลี่ยนเป็นชื่อกลาง ๆ ทั้งหมด ใช้ old.example.com แทนเว็บเก่า new.example.com แทนเว็บใหม่ ชื่อคำสั่งกับชื่อตารางก็ตั้งใหม่ให้อ่านง่าย ส่วนตัวเลขกับลำดับเหตุการณ์เป็นของจริง
อาการ: สัปดาห์เดียว ของที่แก้แล้วกลับมาห้าเรื่อง
คำสั่งนำเข้าอ่านไฟล์สองไฟล์ คือ items.jsonl กับ media.json ที่ได้จากขั้นดึงข้อมูล การดูดครั้งแรกผมเขียนไว้แล้วใน ย้ายเว็บ .aspx เก่าทั้งเว็บ ทำเป็น catalog JSON ส่วนรอบดึงรายสัปดาห์อยู่ใน บทความเรื่องดึงเฉพาะส่วนต่าง บทความนี้เริ่มตรงที่สองไฟล์นั้นมาถึงเครื่องแล้ว และคำถามเดียวที่เหลือคือ ค่าในไฟล์กับค่าที่คนแก้ไว้บนเว็บใหม่ ใครชนะ
ผมออกแบบคำสั่ง import ให้รันซ้ำได้ตั้งแต่แรก คือยึดเลข id ของระบบเก่าเป็นกุญแจ รันกี่รอบก็ไม่เกิดแถวซ้ำ ตรงนี้ทำงานถูก แต่ "รันซ้ำได้" กับ "ไม่ทับของที่คนแก้" เป็นคนละคุณสมบัติกัน และผมมีแค่อย่างแรก อาการเลยโผล่มาทีละเรื่อง
- เปลี่ยนรูปปกหน้าบริการเป็นรูปใหม่ 41 รูป พอ import รอบถัดมา รูปเดิมกลับมาครบ
- รายการซ้ำ 48 รายการ (สินค้า 26 บทความ 14 บริการ 8) ที่รวมไปแล้ว กลับมาอยู่ในสถานะเผยแพร่อีกรอบ
- หน้าทีมงานมี 63 แถวซึ่งเป็นคนจริง 35 คน รวมเสร็จแล้ว แถวซ้ำก็โผล่กลับ
- คำเรียกตำแหน่งที่เจ้าของสั่งแก้ทั้งเว็บ กลับเป็นคำเดิม
- เจ้าของส่งข้อความมาตรง ๆ ว่ารูปที่เลือกแล้วให้ถือเป็นต้นฉบับ ไม่เอารูปเก่ามาทับไปทับมาอีก
ข้อห้าไม่ใช่บั๊ก แต่เป็นข้อที่ทำให้ผมหยุดแก้รายเรื่อง เพราะเจ้าของพูดถูก คนที่นั่งเลือกรูป 41 รูปไม่ควรต้องมาเลือกใหม่ทุกครั้งที่ผม sync
ความคิดแรกที่ผิด: แก้ด้วย SQL แล้วจดไว้ว่าอย่าทับ
สี่เรื่องแรกผมแก้แบบเดียวกันหมด คือเขียน SQL ตรงบน production ทีละเรื่อง แล้วจดลงโน้ตว่ารอบหน้าอย่า import ทับตรงนี้ วิธีนี้พังทุกครั้งที่มีรอบใหม่ ด้วยเหตุผลง่ายมาก คือ importer ไม่ได้อ่านโน้ตของผม มันอ่านแค่ items.jsonl แล้วเขียนทุกช่องที่มันรู้จัก
-- สิ่งที่ผมทำรอบแรก: ตั้งปกใหม่ตรง ๆ บนฐานจริง (เลขในตัวอย่างเป็นเลขสมมติ)
UPDATE services SET cover_media_id = 9051 WHERE id = 118;
-- รอบ import ถัดมา importer ทำแบบนี้กับทุกแถว โดยไม่รู้ว่ามีใครแก้อะไร
UPDATE services SET cover_media_id = 3310 WHERE legacy_id = 2207;
ที่แย่กว่านั้นคือพอเริ่มมีคำสั่ง master ของรูปแล้ว การ set ปกด้วย SQL โดยไม่ลงทะเบียน ก็ยังถูกดึงกลับอยู่ดี เพราะคำสั่ง master ถือว่าตารางลงทะเบียนคือความจริง ค่าที่ไม่ได้ลงทะเบียนเลยเป็นแค่ค่าที่บังเอิญอยู่ตรงนั้น
ถ้าข้อตกลงว่าช่องไหนห้ามแตะ อยู่ในหัวคนหรือในไฟล์โน้ต มันจะหายในรอบที่คนนั้นไม่ได้เป็นคนรัน หรือรันตอนรีบ ข้อตกลงต้องอยู่ในข้อมูลที่ importer อ่านเอง เท่านั้น ไม่อย่างนั้นทุกรอบ sync คือการสุ่มว่าใครจำอะไรได้
ผมเลยถอยมาตั้งคำถามใหม่ว่า หนึ่งช่องของหนึ่งรายการ มีใครมีสิทธิ์เขียนบ้าง คำตอบมีสามเจ้า คือต้นทาง คนที่แก้ในหลังบ้าน และกฎที่เจ้าของสั่งให้ใช้ทั้งเว็บ แต่ละเจ้าต้องการกลไกคนละแบบ
ชั้นที่หนึ่ง: ล็อกช่องที่คนแก้
ชั้นแรกตอบโจทย์ว่า ถ้าคนเข้าไปแก้ช่องไหนในหลังบ้าน ช่องนั้นเป็นของคนตั้งแต่วินาทีนั้น importer ห้ามเขียนอีก ผมเพิ่มตารางคู่ชื่อ legacy_items ไว้จับคู่รายการบนเว็บใหม่กับ id ของระบบเก่า มีคอลัมน์สำคัญสี่ตัวคือ target_type target_id locked_fields (เก็บเป็น JSON) และ duplicate_of
ตอนบันทึกจากหลังบ้าน ก่อน save() จะเรียกฟังก์ชันล็อก ซึ่งใช้ getDirty() ของ Eloquent ดูว่ารอบนี้คนแก้ช่องไหนไปบ้าง แล้วเอาไปตัดกับรายชื่อช่องที่ importer เขียนเท่านั้น ช่องที่ importer ไม่เคยแตะไม่ต้องล็อกให้รก
// app/Support/LegacyLock.php
class LegacyLock
{
/** ช่องที่ importer เขียน ล็อกเฉพาะพวกนี้ */
private const SYNCED = [
'title', 'excerpt', 'body_html', 'cover_media_id', 'price_from',
'seo_title', 'seo_description', 'schedule', 'inclusions', 'images',
];
/** เรียกก่อน save() เสมอ เพราะหลัง save แล้ว getDirty() จะว่าง */
public static function lockDirty(Model $model, array $extra = []): void
{
$fields = array_values(array_intersect(
array_merge(array_keys($model->getDirty()), $extra),
self::SYNCED
));
if (! $fields || ! $model->exists) {
return;
}
$li = LegacyItem::where('target_type', get_class($model))
->where('target_id', $model->getKey())
->whereNull('duplicate_of')
->first();
if ($li) {
$li->locked_fields = array_values(array_unique(
array_merge($li->locked_fields ?? [], $fields)
));
$li->save();
}
}
public static function lockedFor(Model $model): array
{
return LegacyItem::where('target_type', get_class($model))
->where('target_id', $model->getKey())
->whereNull('duplicate_of')
->value('locked_fields') ?? [];
}
}
พารามิเตอร์ $extra มีไว้สำหรับของที่ไม่ใช่คอลัมน์ของ model ตัวนั้น เช่นตารางรายวัน รายการที่รวมในราคา และแกลเลอรีรูป สามอย่างนี้อยู่คนละตาราง getDirty() มองไม่เห็น ฟอร์มหลังบ้านเลยต้องส่งชื่อ schedule inclusions images มาเองเมื่อคนแก้ส่วนนั้น
ฝั่ง importer เปลี่ยนจาก fill() ตรง ๆ เป็น fill ที่ดูรายการล็อกก่อน กติกามีข้อเดียว คือเขียนเมื่อ model ยังไม่มีอยู่ หรือช่องนั้นไม่ถูกล็อก
// ใน importer: fill ที่เคารพช่องที่คนล็อกไว้
private function fillUnlocked(Model $model, array $data, array $locked): void
{
foreach ($data as $field => $value) {
if (! $model->exists || ! in_array($field, $locked, true)) {
$model->{$field} = $value;
}
}
}
// ลำดับต่อหนึ่งรายการ
$locked = $model->exists ? LegacyLock::lockedFor($model) : [];
$this->fillUnlocked($model, $row, $locked);
$model->save();
// ของที่อยู่คนละตาราง เช็กแยกทีละก้อน
if (! in_array('schedule', $locked, true)) {
$this->syncSchedule($model, $item['schedule'] ?? []);
}
if (! in_array('inclusions', $locked, true)) {
$this->syncInclusions($model, $item['inclusions'] ?? []);
}
if (! in_array('images', $locked, true)) {
$this->syncImages($model, $item['image_ids'] ?? []);
}
MediaMaster::applyOverrides($model); // ขั้นสุดท้ายเสมอ ดูหัวข้อถัดไป
ถ้าล็อกทั้งรายการเมื่อมีคนแก้อะไรสักอย่าง รายการนั้นจะหลุดจากการ sync ไปเลย ราคาที่ต้นทางปรับก็ไม่ตามมา การล็อกทีละช่องทำให้คนแก้คำโปรยได้ โดยที่ราคากับตารางรายวันยังตามต้นทางอยู่ ข้อเสียคือรายชื่อช่องที่ importer เขียนต้องตรงกับความจริงเสมอ เพิ่มช่องใหม่ใน importer แล้วลืมเพิ่มใน SYNCED ช่องนั้นจะล็อกไม่ได้
ชั้นที่สอง: override ที่ทับท้ายสุดเสมอ
การล็อกช่องแก้เรื่องคำโปรยกับเนื้อหาได้ แต่ไม่พอสำหรับรูป เพราะรูปปกไม่ได้ถูกเปลี่ยนจากฟอร์มหลังบ้านทุกครั้ง รูปชุด 41 รูปนั้นมาจากงานเปลี่ยนรูปเป็นชุดที่ผมรันตามคำสั่งเจ้าของ ไม่มีใครกดบันทึกทีละรายการ การล็อกเลยไม่เกิด ผมเลยแยกเป็นตารางของมันเอง ชื่อ media_overrides เก็บว่ารายการไหน ช่องรูปไหน ต้องเป็นรูปอะไร
-- โครงย่อของตาราง override: 1 แถว = รูปต้นฉบับของ 1 ช่องรูป
CREATE TABLE media_overrides (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
target_type VARCHAR(20) NOT NULL, -- item | service | post
target_key VARCHAR(64) NOT NULL, -- กุญแจที่ไม่เปลี่ยนเมื่อ import ซ้ำ
slot VARCHAR(20) NOT NULL DEFAULT 'cover',
media_id BIGINT UNSIGNED NOT NULL,
note VARCHAR(255) NULL,
UNIQUE KEY uq_target (target_type, target_key, slot)
) DEFAULT CHARSET = utf8mb4;
importer เรียก applyOverrides($model) เป็นขั้นสุดท้ายหลังเขียนทุกอย่างเสร็จ ลำดับตรงนี้คือทั้งหมดของเรื่อง ไม่ว่าต้นทางจะส่งรูปอะไรมา และไม่ว่าการล็อกช่องจะทำงานหรือไม่ ถ้ามีแถวใน override ค่านั้นชนะ ตัวฟังก์ชันยังไปเพิ่มชื่อช่องรูปลง locked_fields ให้ด้วย เท่ากับกันสองชั้น
คู่กันคือรายการรูปต้องห้าม เก็บเป็น config ธรรมดา ได้แก่รูป QR กับป้ายช่องทางติดต่อของระบบเก่า รูปกลุ่มนี้ถูกถอดออกจากปก จากแกลเลอรี และจาก body ตั้งแต่ตอน import ไม่ต้องรอให้ใครมาเห็นทีหลัง
locked_fields
เกิดเองเมื่อคนกดบันทึกในหลังบ้าน เก็บแค่ชื่อช่อง ไม่เก็บค่า ความหมายคือ importer อย่าเขียนช่องนี้ ใช้กับข้อความ ราคา SEO และของที่คนแก้ทีละรายการ
media_overrides
ลงทะเบียนโดยตั้งใจ เก็บค่าที่ต้องเป็น ความหมายคือไม่ว่าอะไรจะเขียนมาก่อน ค่านี้ทับท้ายสุด ตรวจย้อนหลังได้ว่าตรงหรือไม่ ใช้กับรูปต้นฉบับที่เจ้าของเลือกแล้ว
ความต่างที่ใช้งานจริงคือ override ตรวจได้ เพราะมันเก็บค่าที่ควรเป็น คำสั่ง app:media-master --verify เลยไล่เทียบได้ว่ามีรายการไหนที่ปกจริงไม่ตรงกับที่ลงทะเบียน แล้วรายงานเป็น drift ส่วนการล็อกช่องบอกได้แค่ว่าห้ามแตะ บอกไม่ได้ว่าค่าตอนนี้ถูกหรือผิด
ชั้นที่สาม: กฎหลัง import ที่รันรอบสองต้องได้ 0 แถว
เหลือของกลุ่มสุดท้ายที่ทั้งสองชั้นแรกจัดการไม่ได้ คือกฎที่ใช้กับเนื้อหาทั้งเว็บ เช่นเปลี่ยนคำเรียกตำแหน่ง แก้ลิงก์ที่ยังชี้เว็บเก่า รวมแถวทีมงานที่ซ้ำ กฎพวกนี้ล็อกช่องไม่ได้ เพราะถ้าล็อก body_html ของทุกรายการที่กฎไปแตะ เนื้อหาที่ต้นทางอัปเดตจะไม่เข้ามาอีกเลย
ทางที่ใช้คือปล่อยให้ importer ทับไป แล้วรันกฎซ้ำทุกครั้งหลัง import เป็นชุดคำสั่ง artisan ที่เรียงลำดับตายตัว เงื่อนไขของทุกตัวมีสามข้อ คือมี --dry ไว้ดูก่อนเขียน เป็น idempotent และรันรอบสองทันทีต้องเปลี่ยน 0 แถว
#!/usr/bin/env bash
# post-import.sh — ลำดับตายตัว ห้ามสลับ
set -euo pipefail
# สำรองทั้งก้อนก่อนทุกครั้ง
mysqldump --single-transaction --routines app_db | gzip > "$HOME/backup/pre-import-$(date +%F-%H%M).sql.gz"
php artisan app:import-legacy # อ่าน items.jsonl + media.json
php artisan app:team-merge # รวมแถวทีมงานที่เป็นคนเดียวกัน
php artisan app:scrub-people # ซ่อนบุคคลที่ออกไปแล้ว
php artisan app:content-wording # คำที่เจ้าของสั่งแก้ทั้งเว็บ
php artisan app:fix-links # ลิงก์ที่ยังชี้เว็บเก่า
php artisan app:fill-schedules # แยกตารางรายวันจากเนื้อหา
php artisan app:categorize # จัดหมวด
php artisan app:dedupe # ตัวซ้ำ ตามไฟล์ overrides
php artisan app:zone-images # รูปต่อโซน
php artisan app:content-images # รูปในเนื้อหา
php artisan app:media-master # ทับด้วยรูปต้นฉบับ
php artisan app:content-audit # รวม media-master --verify
ลำดับนี้ผมไม่สลับ แก้คำรันหลังซ่อนบุคคล แก้ลิงก์รันหลังแก้คำ ผมวาง dedupe ไว้ก่อนงานรูป จะได้ไม่ต้องไปเลือกรูปให้รายการที่กำลังจะถูกเก็บเข้าคลัง ส่วน media-master อยู่เกือบท้ายเพราะหน้าที่ของมันคือทับทุกอย่างที่ขั้นก่อนหน้าเขียนไว้ แล้ว audit ปิดท้ายเพื่อดูผลรวม รายละเอียดของสองตัวกลางผมแยกเขียนไว้แล้ว คือ เปลี่ยนคำทั้งฐานข้อมูลโดยไม่พังคำประสม กับ ลิงก์เว็บเก่าที่ฝังในเนื้อหา
วิธีพิสูจน์ว่าทุกตัว idempotent จริงไม่ต้องคิดมาก รันชุดเดิมซ้ำด้วย --dry ทันทีหลังรอบจริง
# รอบสองแบบไม่เขียน ทุกบรรทัดต้องรายงาน 0
for cmd in team-merge scrub-people content-wording fix-links fill-schedules categorize dedupe media-master; do
printf '%-18s ' "$cmd"
php artisan "app:$cmd" --dry | tail -n 1
done
# ตัวตรวจ drift ของรูปต้นฉบับ แยกรันเดี่ยวได้
php artisan app:media-master --verify
ถ้ามีตัวไหนรายงานมากกว่า 0 ในรอบสอง แปลว่ากฎตัวนั้นแก้ผลของตัวเอง หรือสองคำสั่งกำลังแก้ทับกันไปมา ซึ่งต้องหาให้เจอก่อนจะเอาไปรันบน production เพราะอาการแบบนี้บนของจริงคือเนื้อหาที่เปลี่ยนทุกรอบโดยไม่มีใครสั่ง
คำสั่งกลุ่มนี้เขียนฐานข้อมูลตรง ไม่ผ่านฟอร์มหลังบ้าน เลยไม่ไปเพิ่มอะไรใน locked_fields ถ้ามันล็อก เนื้อหา 200 กว่าแถวที่กฎคำไปแตะจะหยุดรับการอัปเดตจากต้นทางทันที การแยกว่า "คนแก้ = ล็อก" กับ "กฎแก้ = ไม่ล็อก แต่รันซ้ำทุกรอบ" คือเส้นแบ่งที่ทำให้ระบบนี้ไม่ค่อย ๆ แข็งตัวจน sync ไม่ได้
ตัวซ้ำไม่ลบ ทีมงานไม่ลบ และ body เก็บ token
เรื่องตัวซ้ำ 48 รายการสอนผมอีกข้อ คือการลบเป็นทางที่แย่ที่สุด เพราะรอบ import ถัดไปต้นทางยังมีรายการนั้นอยู่ importer ไม่เห็นบนเว็บใหม่ก็สร้างใหม่ วนกลับมาที่เดิม สิ่งที่ทำแทนคือ
- ตัวซ้ำถูกเก็บเข้าคลัง กู้คืนได้ และ URL เดิมของมันตอบ 301 ไปตัวที่เก็บไว้ แถว
legacy_itemsของตัวซ้ำมีduplicate_ofชี้ไปตัวหลัก importer เห็นแล้วข้าม - เกณฑ์ว่าซ้ำคือ โซนเดียวกัน เนื้อหาเหมือนกันอย่างน้อย 87% และระยะเวลาเท่ากัน
- คู่ที่ตัดสินแล้วเก็บในไฟล์ overrides ฝั่ง pipeline ด้วย เพื่อไม่ให้กลับมาตั้งแต่ต้นทาง ไม่ใช่มาตัดทิ้งที่ปลายทางทุกรอบ
{
"merge": [
{ "keep": 1204, "drop": 1877, "why": "รายการเดียวกัน ลงสองโดเมน" },
{ "keep": 1530, "drop": 1531, "why": "บทความลงซ้ำ" }
],
"not_duplicate": [
[2011, 2012]
]
}
เลข id ในตัวอย่างเป็นเลขสมมติ แต่โครงเป็นแบบนี้ ช่อง not_duplicate สำคัญพอกับ merge เพราะบางคู่เครื่องบอกว่าซ้ำแต่คนดูแล้วบอกว่าไม่ ถ้าไม่จดไว้ รอบหน้าเครื่องก็เสนอคู่เดิมอีก
ทีมงานใช้หลักเดียวกัน 63 แถวเหลือ 35 คนโดยไม่ลบสักแถว แถวซ้ำมี merged_into_id ชี้ไปแถวหลักแล้วถูกซ่อนจากหน้าเว็บ importer ข้ามแถวที่ merge แล้ว ส่วนรายการที่ต้นทางลบไปเอง ผมก็เก็บเข้าคลังเหมือนกัน ไม่ลบ และแยกออกจากรายการที่ต้นทางแค่ย้ายไปอยู่โดเมนพี่น้อง ซึ่งเป็นคนละกรณี
อีกจุดที่ลดงานซ้ำได้มากคือรูปแบบของ body_html เนื้อหาไม่เก็บ URL ของรูปกับลิงก์ภายในตรง ๆ แต่เก็บเป็น token แล้วค่อยแปลงตอนแสดงผล
// เก็บ: <img src="{{media:3310}}"> <a href="{{legacy:2207}}">ดูรายละเอียด</a>
// แสดง: แปลง token เป็น URL จริง ณ เวลา render
public static function render(string $html): string
{
return preg_replace_callback('/\{\{(media|legacy):([\w-]+)\}\}/', function ($m) {
return $m[1] === 'media'
? MediaUrl::for($m[2]) // ไฟล์รูปปัจจุบันของ media นั้น
: LegacyUrl::for((int) $m[2]); // URL ปัจจุบันของรายการที่มาจาก id เก่า
}, $html);
}
ผลคือเปลี่ยนไฟล์รูป เปลี่ยนรูปแบบ URL หรือรวมรายการสองตัวเป็นตัวเดียว ไม่ต้องไล่แก้ body สักแถว เพราะ body ไม่เคยรู้ URL จริงมาตั้งแต่ต้น
ลำดับที่ใช้จริงก่อนแตะ production
ยอดหลังจัดการครบทุกชั้นคือ สินค้า 401 บทความ 796 บริการ 249
ข้อที่ต้องคิดเผื่อมีสองข้อ ข้อแรก การล็อกเป็นทางเดียวโดยธรรมชาติ ช่องที่ถูกล็อกแล้วจะไม่ตามต้นทางอีกจนกว่าจะมีคนเอาชื่อช่องออกจาก locked_fields ถ้าคนแก้เว็บมีหลายคน ควรมีหน้าที่แสดงว่าช่องไหนล็อกอยู่และมีทางปลดให้ชัด ข้อสอง รายชื่อช่องใน SYNCED กับสิ่งที่ importer เขียนจริงต้องดูแลให้ตรงกันเอง เพิ่มช่องฝั่งหนึ่งแล้วลืมอีกฝั่งคือรูรั่ว ส่วนตัวผมคิดว่าสองข้อนี้ยอมรับได้เมื่อเทียบกับการที่คนต้องมานั่งเลือกรูปใหม่ทุกรอบ sync แต่จะลงแรงกับสองเรื่องนี้แค่ไหนก็ตามขนาดทีมและตามสะดวก
สรุปคือเวลาเว็บใหม่ยังต้องรับของจากระบบเก่า อย่าถามว่า import รันซ้ำได้ไหม ให้ถามว่าแต่ละช่องเป็นของใคร แล้วให้คำตอบนั้นอยู่ในตารางที่ importer อ่าน คนแก้ให้ล็อกช่อง ของที่ต้องเป็นค่าเดียวเสมอให้ลง override แล้วทับท้ายสุด ส่วนกฎทั้งเว็บให้เป็นคำสั่งที่รันซ้ำแล้วได้ 0 แถว ตรงไหนผมอธิบายตกหล่นหรือพิมพ์ผิด เดี๋ยวกลับมาแก้เพิ่มให้ภายหลังครับ
อยากให้เราทำให้ไหม?
ให้เราช่วยติดตั้ง ตั้งค่า ย้ายระบบ หรือแก้ปัญหาเซิร์ฟเวอร์ เพื่อให้คุณมีเวลาไปทำงานที่สำคัญกว่า
เคยเจองานแบบนี้ไหม? ติดตรงไหน?
มาแลกวิธีกันต่อในบอร์ด LinuxThai



ความคิดเห็น 0
ยังไม่มีความคิดเห็น — เป็นคนแรกเลย