ນີ້ແມ່ນຄໍາສັ່ງ pt-table-syncp ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
pt-table-sync - ຊິ້ງຂໍ້ມູນຕາຕະລາງ MySQL ຢ່າງມີປະສິດທິພາບ.
ສະຫຼຸບສັງລວມ
ການນໍາໃຊ້: pt-table-sync [ຕົວເລືອກ] DSN [DSN]
pt-table-sync synchronizes ຂໍ້ມູນຢ່າງມີປະສິດທິພາບລະຫວ່າງຕາຕະລາງ MySQL.
ເຄື່ອງມືນີ້ປ່ຽນແປງຂໍ້ມູນ, ດັ່ງນັ້ນເພື່ອຄວາມປອດໄພສູງສຸດ, ທ່ານຄວນສໍາຮອງຂໍ້ມູນຂອງທ່ານກ່ອນທີ່ຈະນໍາໃຊ້
ມັນ. ເມື່ອ synchronizing ເຄື່ອງແມ່ຂ່າຍທີ່ເປັນສໍາລອງ replication ກັບ "--replicate" ຫຼື
ວິທີການ "--sync-to-master", ມັນ ສະເຫມີໄປ ເຮັດໃຫ້ການປ່ຽນແປງກ່ຽວກັບແມ່ບົດການຈໍາລອງ, ບໍ່ເຄີຍ
ສໍາລອງການຈໍາລອງໂດຍກົງ. ໂດຍທົ່ວໄປແລ້ວນີ້ແມ່ນວິທີດຽວທີ່ປອດໄພທີ່ຈະນໍາເອົາການຈໍາລອງ
ກັບຄືນໄປບ່ອນຢູ່ໃນ sync ກັບຕົ້ນສະບັບຂອງຕົນ; ການປ່ຽນແປງຂອງ replica ປົກກະຕິແລ້ວແມ່ນແຫຼ່ງຂອງ
ບັນຫາໃນສະຖານທີ່ທໍາອິດ. ຢ່າງໃດກໍຕາມ, ການປ່ຽນແປງທີ່ມັນເຮັດຢູ່ໃນແມ່ບົດຄວນຈະເປັນ no-op
ການປ່ຽນແປງທີ່ກໍານົດຂໍ້ມູນທີ່ເປັນຄ່າປະຈຸບັນຂອງເຂົາເຈົ້າ, ແລະຕົວຈິງແລ້ວຜົນກະທົບພຽງແຕ່ replica ໄດ້.
ຊິງ db.tbl ໃນ host1 ກັບ host2:
pt-table-sync --execute h=host1,D=db,t=tbl h=host2
Sync ຕາຕະລາງທັງຫມົດໃນ host1 ກັບ host2 ແລະ host3:
pt-table-sync --execute host1 host2 host3
ເຮັດໃຫ້ slave1 ມີຂໍ້ມູນດຽວກັນກັບແມ່ແບບການຈໍາລອງຂອງມັນ:
pt-table-sync --execute --sync-to-master slave1
ແກ້ໄຂຄວາມແຕກຕ່າງທີ່ pt-table-checksum ພົບເຫັນຢູ່ໃນ slave ທັງຫມົດຂອງ master1:
pt-table-sync --execute --replicate test.checksum master1
ຄືກັນກັບຂ້າງເທິງແຕ່ພຽງແຕ່ແກ້ໄຂຄວາມແຕກຕ່າງໃນ slave1:
pt-table-sync --execute --replicate test.checksum \
--sync-to-master slave1
Sync master2 ໃນການຕັ້ງຄ່າ replication master-master, ບ່ອນທີ່ສໍາເນົາ master2 ຂອງ db.tbl
ເປັນທີ່ຮູ້ຈັກ ຫຼືສົງໃສວ່າບໍ່ຖືກຕ້ອງ:
pt-table-sync --execute --sync-to-master h=master2,D=db,t=tbl
ໃຫ້ສັງເກດວ່າໃນການຕັ້ງຄ່າຕົ້ນສະບັບ, ຕໍ່ໄປນີ້ຈະບໍ່ເຮັດສິ່ງທີ່ທ່ານຕ້ອງການ,
ເນື່ອງຈາກວ່າມັນຈະເຮັດການປ່ຽນແປງໂດຍກົງໃນ master2, ເຊິ່ງຫຼັງຈາກນັ້ນຈະໄຫຼຜ່ານ replication
ແລະປ່ຽນຂໍ້ມູນຂອງ master1:
# ຢ່າເຮັດອັນນີ້ໃນການຕັ້ງຄ່າຕົ້ນສະບັບ!
pt-table-sync --execute h=master1,D=db,t=tbl master2
RISKS
ຄໍາເຕືອນ: pt-table-sync ການປ່ຽນແປງຂໍ້ມູນ! ກ່ອນທີ່ຈະໃຊ້ເຄື່ອງມືນີ້, ກະລຸນາ:
· ອ່ານເອກະສານຂອງເຄື່ອງມື
·ທົບທວນເຄື່ອງມືທີ່ຮູ້ຈັກ "BUGS"
· ທົດສອບເຄື່ອງມືໃນເຊີບເວີທີ່ບໍ່ແມ່ນການຜະລິດ
·ສໍາຮອງເຄື່ອງແມ່ຂ່າຍການຜະລິດຂອງທ່ານແລະກວດສອບການສໍາຮອງຂໍ້ມູນ
pt-table-sync ແມ່ນຜູ້ໃຫຍ່, ພິສູດໃນໂລກທີ່ແທ້ຈິງ, ແລະທົດສອບໄດ້ດີ, ແຕ່ຖ້າໃຊ້
ບໍ່ຖືກຕ້ອງ, ມັນສາມາດມີຜົນກະທົບທາງລົບ. ສະເຫມີທົດສອບ syncing ທໍາອິດກັບ
"--dry-run" ແລະ "--print".
ລາຍລະອຽດ
pt-table-sync ເຮັດການ synchronization ແບບທາງດຽວແລະສອງທິດທາງຂອງຂໍ້ມູນຕາຕະລາງ. ມັນເຮັດ ບໍ່
synchronize ໂຄງສ້າງຕາຕະລາງ, ດັດຊະນີ, ຫຼືວັດຖຸ schema ອື່ນໆ. ຕໍ່ໄປນີ້
ອະທິບາຍການ synchronization ທາງດຽວ. "BIDIRECTIONAL SYNCING" ແມ່ນອະທິບາຍຕໍ່ມາ.
ເຄື່ອງມືນີ້ແມ່ນສະລັບສັບຊ້ອນແລະເຮັດວຽກໃນຫຼາຍວິທີທີ່ແຕກຕ່າງກັນ. ການນໍາໃຊ້ມັນຢ່າງປອດໄພແລະ
ປະສິດທິຜົນ, ທ່ານຄວນເຂົ້າໃຈສາມຢ່າງ: ຈຸດປະສົງຂອງ "--replicate", ຊອກຫາ
ຄວາມແຕກຕ່າງ, ແລະການລະບຸເຈົ້າພາບ. ສາມແນວຄວາມຄິດນີ້ແມ່ນກ່ຽວຂ້ອງຢ່າງໃກ້ຊິດແລະກໍານົດ
ເຄື່ອງມືຈະເຮັດວຽກແນວໃດ. ຕໍ່ໄປນີ້ແມ່ນເຫດຜົນຫຍໍ້:
ຖ້າ DSN ມີສ່ວນຫນຶ່ງ, ໃຫ້ sync ພຽງແຕ່ຕາຕະລາງນັ້ນ:
ຖ້າ 1 DSN:
ຖ້າ --sync-to-master:
DSN ເປັນສໍາລອງ. ເຊື່ອມຕໍ່ກັບຕົ້ນສະບັບຂອງມັນແລະ sync.
ຖ້າຫຼາຍກວ່າ 1 DSN:
DSN ທໍາອິດແມ່ນແຫຼ່ງ. ຊິ້ງ DSN ແຕ່ລະອັນ.
ອື່ນຖ້າ --replicate:
ຖ້າ --sync-to-master:
DSN ເປັນສໍາລອງ. ເຊື່ອມຕໍ່ກັບແມ່ບົດຂອງມັນ, ຊອກຫາບັນທຶກ
ຄວາມແຕກຕ່າງ, ແລະແກ້ໄຂ.
ອື່ນ:
DSN ແມ່ນແມ່ບົດ. ຊອກຫາສໍາລອງແລະເຊື່ອມຕໍ່ກັບແຕ່ລະຄົນ,
ຊອກຫາບັນທຶກຄວາມແຕກຕ່າງ, ແລະແກ້ໄຂ.
ອື່ນ:
ຖ້າພຽງແຕ່ 1 DSN ແລະ --sync-to-master:
DSN ເປັນສໍາລອງ. ເຊື່ອມຕໍ່ກັບແມ່ບົດຂອງມັນ, ຊອກຫາຕາຕະລາງແລະ
ການກັ່ນຕອງກັບ --databases ແລະອື່ນໆ, ແລະ sync ແຕ່ລະຕາຕະລາງກັບແມ່ບົດ.
ອື່ນ:
ຊອກຫາຕາຕະລາງ, ການກັ່ນຕອງກັບ --databases ແລະອື່ນໆ, ແລະ sync ແຕ່ລະຄົນ
DSN ກັບຄັ້ງທໍາອິດ.
pt-table-sync ສາມາດດໍາເນີນການໃນຫນຶ່ງໃນສອງວິທີ: ດ້ວຍ "--replicate" ຫຼືບໍ່ມີ. ຄ່າເລີ່ມຕົ້ນແມ່ນ
ເພື່ອດໍາເນີນການໂດຍບໍ່ມີ "--replicate" ເຊິ່ງເຮັດໃຫ້ pt-table-sync ເພື່ອຊອກຫາຄວາມແຕກຕ່າງໂດຍອັດຕະໂນມັດ
ປະສິດທິພາບດ້ວຍໜຶ່ງໃນຫຼາຍສູດການຄິດໄລ່ (ເບິ່ງ "ALGORITHMS"). ອີກທາງເລືອກ, ມູນຄ່າ
ຂອງ "--replicate", ຖ້າລະບຸ, ເຮັດໃຫ້ pt-table-sync ໃຊ້ຄວາມແຕກຕ່າງທີ່ພົບແລ້ວ
ໂດຍການດໍາເນີນການ pt-table-checksum ກ່ອນຫນ້ານີ້ດ້ວຍຕົວເລືອກ "--replicate" ຂອງຕົນເອງ. ຢ່າງເຂັ້ມງວດ
ເວົ້າ, ທ່ານບໍ່ຈໍາເປັນຕ້ອງໃຊ້ "--replicate" ເພາະວ່າ pt-table-sync ສາມາດຊອກຫາຄວາມແຕກຕ່າງ,
ແຕ່ຫຼາຍຄົນໃຊ້ "--replicate" ຖ້າ, ຕົວຢ່າງ, ພວກເຂົາ checksum ເປັນປົກກະຕິໂດຍໃຊ້ pt-table-
checksum ຫຼັງຈາກນັ້ນແກ້ໄຂຄວາມແຕກຕ່າງຕາມຄວາມຕ້ອງການກັບ pt-table-sync. ຖ້າເຈົ້າບໍ່ແນ່ໃຈ, ອ່ານແຕ່ລະອັນ
ເອກະສານຂອງເຄື່ອງມືຢ່າງລະມັດລະວັງແລະຕັດສິນໃຈສໍາລັບຕົວທ່ານເອງ, ຫຼືປຶກສາກັບຜູ້ຊ່ຽວຊານ.
ໂດຍບໍ່ຄໍານຶງວ່າ "--replicate" ຖືກນໍາໃຊ້ຫຼືບໍ່, ທ່ານຈໍາເປັນຕ້ອງລະບຸວ່າເຈົ້າພາບໃດ
ຊິງຄ໌. ມີສອງວິທີ: ດ້ວຍ "--sync-to-master" ຫຼືບໍ່ມີ. ການລະບຸ
"--sync-to-master" ເຮັດໃຫ້ pt-table-sync ຄາດຫວັງວ່າຫນຶ່ງແລະພຽງແຕ່ slave DSN ຢູ່ໃນເສັ້ນຄໍາສັ່ງ.
ເຄື່ອງມືອັດຕະໂນມັດຈະຄົ້ນພົບຕົ້ນສະບັບຂອງສໍາລອງແລະ sync ມັນເພື່ອໃຫ້ຂໍ້ມູນຂອງມັນ
ຄືກັນກັບນາຍຂອງມັນ. ນີ້ແມ່ນສໍາເລັດໂດຍການເຮັດໃຫ້ການປ່ຽນແປງໃນຕົ້ນສະບັບຊຶ່ງຫຼັງຈາກນັ້ນ
ໄຫຼໂດຍຜ່ານການຈໍາລອງແລະປັບປຸງສໍາລອງເພື່ອແກ້ໄຂຄວາມແຕກຕ່າງຂອງມັນ. Be ລະມັດລະວັງ
ເຖິງແມ່ນວ່າ: ເຖິງແມ່ນວ່າທາງເລືອກນີ້ກໍານົດແລະ syncs slave ດຽວ, ຖ້າຫາກວ່າມີສໍາລອງອື່ນໆ
ໃນຕົ້ນສະບັບດຽວກັນ, ພວກເຂົາເຈົ້າຈະໄດ້ຮັບໂດຍຜ່ານການ replication ການປ່ຽນແປງທີ່ມີຈຸດປະສົງສໍາລັບສໍາລອງ
ທີ່ທ່ານກໍາລັງພະຍາຍາມ sync.
ອີກທາງເລືອກ, ຖ້າທ່ານບໍ່ລະບຸ "--sync-to-master", DSN ທໍາອິດທີ່ໃຫ້ຢູ່ໃນ
ເສັ້ນຄໍາສັ່ງແມ່ນເຈົ້າພາບແຫຼ່ງ. ມີພຽງແຕ່ຫນຶ່ງທີ່ເຄີຍເປັນເຈົ້າພາບແຫຼ່ງ. ຖ້າເຈົ້າເຮັດບໍ່ໄດ້ຄືກັນ
ລະບຸ "--replicate", ຫຼັງຈາກນັ້ນທ່ານຕ້ອງລະບຸຢ່າງຫນ້ອຍຫນຶ່ງ DSN ອື່ນໆເປັນຈຸດຫມາຍປາຍທາງ
ເຈົ້າພາບ. ສາມາດມີໂຮສປາຍທາງໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ. ເຈົ້າພາບແຫຼ່ງແລະປາຍທາງຕ້ອງເປັນ
ເອກະລາດ; ພວກມັນບໍ່ສາມາດຢູ່ໃນ topology replication ດຽວກັນ. pt-table-sync ຈະຕາຍດ້ວຍ
ຂໍ້ຜິດພາດຖ້າມັນກວດພົບວ່າເຈົ້າພາບປາຍທາງເປັນທາດເພາະວ່າການປ່ຽນແປງຖືກຂຽນ
ໂດຍກົງກັບເຈົ້າພາບປາຍທາງ (ແລະມັນບໍ່ປອດໄພທີ່ຈະຂຽນໂດຍກົງຫາສໍາລອງ). ຫຼື, ຖ້າທ່ານ
ລະບຸ "--replicate" (ແຕ່ບໍ່ແມ່ນ "--sync-to-master") ຫຼັງຈາກນັ້ນ pt-table-sync ຄາດວ່າຈະເປັນອັນດຽວ.
ຫນຶ່ງຕົ້ນສະບັບ DSN ໃນເສັ້ນຄໍາສັ່ງ. ເຄື່ອງມືອັດຕະໂນມັດຈະຄົ້ນພົບຕົ້ນສະບັບທັງຫມົດ
ສໍາລອງແລະ sync ໃຫ້ເຂົາເຈົ້າກັບຕົ້ນສະບັບ. ນີ້ແມ່ນວິທີດຽວທີ່ຈະ sync ຫຼາຍ (ທັງຫມົດ) ສໍາລອງຢູ່
ຄັ້ງດຽວ (ເນື່ອງຈາກວ່າ "--sync-to-master" ພຽງແຕ່ກໍານົດຫນຶ່ງສໍາລອງ).
ແຕ່ລະໂຮດຢູ່ໃນເສັ້ນຄໍາສັ່ງແມ່ນຖືກກໍານົດເປັນ DSN. DSN ທໍາອິດ (ຫຼືພຽງແຕ່ DSN ສໍາລັບກໍລະນີ
ເຊັ່ນ "--sync-to-master") ສະຫນອງຄ່າເລີ່ມຕົ້ນສໍາລັບ DSNs ອື່ນໆ, ບໍ່ວ່າຈະເປັນ DSNs ອື່ນໆ.
ຖືກລະບຸໄວ້ໃນເສັ້ນຄໍາສັ່ງຫຼືການຄົ້ນພົບອັດຕະໂນມັດໂດຍເຄື່ອງມື. ດັ່ງນັ້ນ, ໃນຕົວຢ່າງນີ້,
pt-table-sync --execute h=host1,u=msandbox,p=msandbox h=host2
host2 DSN ສືບທອດສ່ວນ "u" ແລະ "p" DSN ຈາກ host1 DSN. ໃຊ້
"--explain-hosts" ທາງເລືອກເພື່ອເບິ່ງວ່າ pt-table-sync ຈະຕີຄວາມໝາຍຂອງ DSNs ທີ່ໃຫ້ຢູ່ໃນ
ບັນທັດຄໍາສັ່ງ.
OUTPUT
ຖ້າທ່ານລະບຸຕົວເລືອກ "--verbose", ທ່ານຈະເຫັນຂໍ້ມູນກ່ຽວກັບຄວາມແຕກຕ່າງ
ລະຫວ່າງຕາຕະລາງ. ມີຫນຶ່ງແຖວຕໍ່ຕາຕະລາງ. ແຕ່ລະເຄື່ອງແມ່ຂ່າຍແມ່ນພິມແຍກຕ່າງຫາກ. ສໍາລັບ
ຍົກຕົວຢ່າງ,
# ການຊິງຄ໌ h=host1,D=test,t=test1
# ລຶບການປ່ຽນແທນໃສ່ algorithm ອັບເດດເລີ່ມຕົ້ນ END ອອກຈາກ DATABASE.TABLE
# 0 0 3 0 Chunk 13:00:00 13:00:17 2 test.test1
ຕາຕະລາງ test.test1 ໃນ host1 ຕ້ອງການ 3 "INSERT" statements ເພື່ອ synchronize ແລະມັນໄດ້ໃຊ້
Chuk algorithm (ເບິ່ງ "ALGORITHMS"). ການດໍາເນີນງານ sync ສໍາລັບຕາຕະລາງນີ້ໄດ້ເລີ່ມຕົ້ນທີ່ 13:00:00
ແລະສິ້ນສຸດ 17 ວິນາທີຕໍ່ມາ (ເວລາທີ່ເອົາມາຈາກ "NOW()" ໃນໂຮດຕົ້ນສະບັບ). ເນື່ອງຈາກວ່າ
ຄວາມແຕກຕ່າງໄດ້ຖືກພົບເຫັນ, "ສະຖານະການອອກ" ຂອງມັນແມ່ນ 2.
ຖ້າທ່ານລະບຸຕົວເລືອກ "--print", ທ່ານຈະເຫັນຂໍ້ຄວາມ SQL ຕົວຈິງທີ່ສະຄິບ
ໃຊ້ເພື່ອ synchronize ຕາຕະລາງຖ້າ "--execute" ຖືກລະບຸໄວ້.
ຖ້າທ່ານຕ້ອງການເບິ່ງຂໍ້ຄວາມ SQL ທີ່ pt-table-sync ກໍາລັງໃຊ້ເພື່ອເລືອກ chunks,
nibbles, ແຖວ, ແລະອື່ນໆ, ຫຼັງຈາກນັ້ນລະບຸ "--print" ຫນຶ່ງຄັ້ງແລະ "--verbose" ສອງຄັ້ງ. ລະມັດລະວັງ
ເຖິງແມ່ນວ່າ: ນີ້ສາມາດພິມຄໍາຖະແຫຼງ SQL ຫຼາຍ.
ມີກໍລະນີທີ່ບໍ່ມີການປະສົມປະສານຂອງ "INSERT", "UPDATE" ຫຼື "DELETE" ສາມາດເຮັດໄດ້
ແກ້ໄຂຄວາມແຕກຕ່າງໂດຍບໍ່ມີການລະເມີດບາງລະຫັດທີ່ບໍ່ຊ້ໍາກັນ. ຕົວຢ່າງ, ສົມມຸດວ່າມີ
ກະແຈຫຼັກໃນຖັນ a ແລະກະແຈສະເພາະໃນຖັນ b. ຫຼັງຈາກນັ້ນ, ບໍ່ມີວິທີທີ່ຈະ sync ເຫຼົ່ານີ້
ສອງຕາຕະລາງທີ່ມີຂໍ້ຄວາມ UPDATE ກົງໄປກົງມາ:
+---+--+ +---+---+
| a | b | | a | b |
+---+--+ +---+---+
| 1 | 2 | | 1 | 1 |
| 2 | 1 | | 2 | 2 |
+---+--+ +---+---+
ເຄື່ອງມືຂຽນຄໍາຖາມຄືນໃຫມ່ເປັນ "DELETE" ແລະ "REPLACE" ໃນກໍລະນີນີ້. ນີ້ແມ່ນອັດຕະໂນມັດ
ຈັດການຫຼັງຈາກການລະເມີດດັດສະນີທໍາອິດ, ດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງກັງວົນກ່ຽວກັບມັນ.
ຈົ່ງລະມັດລະວັງໃນເວລາໃຊ້ pt-table-sync ໃນການຕັ້ງຄ່າ master-master ໃດໆ. ການຈໍາລອງແບບຕົ້ນສະບັບ
ໂດຍພື້ນຖານແລ້ວແມ່ນ tricky, ແລະມັນງ່າຍທີ່ຈະເຮັດຜິດພາດ. ທ່ານຈໍາເປັນຕ້ອງໃຫ້ແນ່ໃຈວ່າທ່ານກໍາລັງໃຊ້
ເຄື່ອງມືທີ່ຖືກຕ້ອງສໍາລັບການຈໍາລອງແບບຕົ້ນສະບັບ. ເບິ່ງ "SYNOPSIS" ສໍາລັບສະພາບລວມຂອງ
ການນໍາໃຊ້ທີ່ຖືກຕ້ອງ.
ນອກຈາກນັ້ນ, ຈົ່ງລະມັດລະວັງກັບຕາຕະລາງທີ່ມີຂໍ້ຈໍາກັດຂອງລະຫັດຕ່າງປະເທດທີ່ມີ "ON DELETE" ຫຼື "ON
UPDATE" ຄໍານິຍາມເພາະວ່າສິ່ງເຫຼົ່ານີ້ອາດຈະເຮັດໃຫ້ເກີດການປ່ຽນແປງທີ່ບໍ່ໄດ້ຕັ້ງໃຈຢູ່ໃນຕາຕະລາງເດັກນ້ອຍ. ເບິ່ງ
"--[ບໍ່]ຕາຕະລາງກວດເດັກນ້ອຍ".
ໂດຍທົ່ວໄປ, ເຄື່ອງມືນີ້ແມ່ນເຫມາະສົມທີ່ສຸດເມື່ອຕາຕະລາງຂອງທ່ານມີລະຫັດຕົ້ນຕໍຫຼືດັດຊະນີທີ່ເປັນເອກະລັກ.
ເຖິງແມ່ນວ່າມັນສາມາດ synchronize ຂໍ້ມູນໃນຕາຕະລາງທີ່ຂາດລະຫັດຕົ້ນຕໍຫຼືດັດສະນີເປັນເອກະລັກ, ມັນອາດຈະ
ດີທີ່ສຸດທີ່ຈະ synchronize ຂໍ້ມູນນັ້ນໂດຍວິທີອື່ນ.
REPLLICATION ຄວາມປອດໄພ
ການ synchronizing ນາຍແບບຈໍາລອງແລະສໍາລອງຢ່າງປອດໄພແມ່ນບັນຫາທີ່ບໍ່ແມ່ນເລື່ອງເລັກນ້ອຍ, ໂດຍທົ່ວໄປ.
ມີທຸກປະເພດຂອງບັນຫາທີ່ຈະຄິດກ່ຽວກັບ, ເຊັ່ນ: ຂະບວນການອື່ນໆການປ່ຽນແປງຂໍ້ມູນ,
ພະຍາຍາມປ່ຽນແປງຂໍ້ມູນໃນ slave, ບໍ່ວ່າຈະເປັນຈຸດຫມາຍປາຍທາງແລະແຫຼ່ງແມ່ນ master-master
ຄູ່, ແລະອື່ນໆອີກ.
ໂດຍທົ່ວໄປ, ວິທີທີ່ປອດໄພທີ່ຈະເຮັດແມ່ນການປ່ຽນແປງຂໍ້ມູນໃນແມ່ບົດ, ແລະປ່ອຍໃຫ້ການປ່ຽນແປງ
ໄຫຼໂດຍຜ່ານການຈໍາລອງກັບສໍາລອງຄືກັບການປ່ຽນແປງອື່ນໆ. ຢ່າງໃດກໍຕາມ, ນີ້ເຮັດວຽກພຽງແຕ່ຖ້າຫາກວ່າ
ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນແທນໃນຕາຕະລາງເທິງແມ່ບົດ. REPLACE ເຮັດວຽກພຽງແຕ່ຖ້າວ່າມີ
ດັດຊະນີທີ່ເປັນເອກະລັກໃນຕາຕະລາງ (ຖ້າບໍ່ດັ່ງນັ້ນມັນພຽງແຕ່ປະຕິບັດຄືກັບ INSERT ທໍາມະດາ).
ຖ້າຕາຕະລາງຂອງເຈົ້າມີກະແຈທີ່ເປັນເອກະລັກ, ທ່ານຄວນໃຊ້ "--sync-to-master" ແລະ/ຫຼື "--replicate"
ທາງເລືອກໃນການຊິງສໍາລອງກັບນາຍຂອງຕົນ. ນີ້ໂດຍທົ່ວໄປແລ້ວຈະເຮັດສິ່ງທີ່ຖືກຕ້ອງ. ເມື່ອໃດ
ບໍ່ມີກະແຈທີ່ເປັນເອກະລັກໃນຕາຕະລາງ, ບໍ່ມີທາງເລືອກອື່ນນອກຈາກການປ່ຽນຂໍ້ມູນໃນ
slave, ແລະ pt-table-sync ຈະກວດພົບວ່າທ່ານກໍາລັງພະຍາຍາມເຮັດແນວນັ້ນ. ມັນຈະຈົ່ມແລະ
ຕາຍເວັ້ນເສຍແຕ່ວ່າທ່ານລະບຸ "--no-check-slave" (ເບິ່ງ "--[no]check-slave").
ຖ້າທ່ານກໍາລັງຊິ້ງຕາຕະລາງໂດຍບໍ່ມີລະຫັດຕົ້ນຕໍຫຼືເປັນເອກະລັກຂອງຄູ່ຕົ້ນສະບັບ, ທ່ານ
ຕ້ອງປ່ຽນຂໍ້ມູນໃນເຊີບເວີປາຍທາງ. ດັ່ງນັ້ນ, ທ່ານຈໍາເປັນຕ້ອງກໍານົດ
"--no-bin-log" ເພື່ອຄວາມປອດໄພ (ເບິ່ງ "--[no]bin-log"). ຖ້າທ່ານບໍ່ເຮັດ, ການປ່ຽນແປງທີ່ທ່ານເຮັດ
ເຄື່ອງແມ່ຂ່າຍປາຍທາງຈະ replicate ກັບຄືນໄປບ່ອນເຄື່ອງແມ່ຂ່າຍແຫຼ່ງແລະການປ່ຽນແປງຂໍ້ມູນມີ!
ໂດຍທົ່ວໄປແລ້ວສິ່ງທີ່ປອດໄພທີ່ຈະເຮັດໃນຄູ່ master-master ແມ່ນການໃຊ້ "--sync-to-master"
ທາງເລືອກເພື່ອໃຫ້ທ່ານບໍ່ປ່ຽນແປງຂໍ້ມູນໃນເຄື່ອງແມ່ຂ່າຍປາຍທາງ. ນອກນັ້ນທ່ານຍັງຈະຕ້ອງໄດ້
ລະບຸ "--no-check-slave" ເພື່ອຮັກສາ pt-table-sync ຈາກການຈົ່ມວ່າມັນກໍາລັງປ່ຽນແປງຂໍ້ມູນ
ສຸດສໍາລອງ.
ALGORITHMS
pt-table-sync ມີກອບການຊິ້ງຂໍ້ມູນທົ່ວໄປທີ່ໃຊ້ສູດການຄິດໄລ່ທີ່ແຕກຕ່າງກັນເພື່ອຊອກຫາ
ຄວາມແຕກຕ່າງ. ເຄື່ອງມືອັດຕະໂນມັດເລືອກ algorithm ທີ່ດີທີ່ສຸດສໍາລັບແຕ່ລະຕາຕະລາງໂດຍອີງໃສ່
ດັດສະນີ, ປະເພດຖັນ, ແລະການຕັ້ງຄ່າສູດການຄິດໄລ່ທີ່ລະບຸໂດຍ "--algorithms". ໄດ້
ສູດການຄິດໄລ່ຕໍ່ໄປນີ້ແມ່ນມີຢູ່, ລະບຸໄວ້ໃນລຳດັບຄວາມມັກເລີ່ມຕົ້ນຂອງພວກມັນ:
ຄອກ
ຊອກຫາດັດຊະນີທີ່ມີຖັນທຳອິດເປັນຕົວເລກ (ລວມທັງປະເພດວັນທີ ແລະເວລາ), ແລະ
ແບ່ງຊ່ວງຄ່າຂອງຖັນອອກເປັນຕ່ອນປະມານ "--chunk-size" ແຖວ.
ຊິງຄ໌ຄັ້ງລະອັນໂດຍ checksumming ທັງໝົດ. ຖ້າ chunk ແຕກຕ່າງກັນກ່ຽວກັບ
ແຫຼ່ງແລະປາຍທາງ, checksums ແຕ່ລະແຖວຂອງ chunk ສ່ວນບຸກຄົນເພື່ອຊອກຫາແຖວນັ້ນ
ແຕກຕ່າງກັນ.
ມັນມີປະສິດທິພາບເມື່ອຖັນມີ cardinality ພຽງພໍເພື່ອເຮັດໃຫ້ chunks ສິ້ນສຸດລົງ
ກ່ຽວກັບຂະຫນາດທີ່ເຫມາະສົມ.
ການກວດກາຕໍ່ຄັ້ງເບື້ອງຕົ້ນແມ່ນຂ້ອນຂ້າງນ້ອຍ ແລະສົ່ງຜົນໃຫ້ມີການຈະລາຈອນເຄືອຂ່າຍໜ້ອຍທີ່ສຸດ
ແລະການບໍລິໂພກຄວາມຊົງຈໍາ. ຖ້າແຖວຂອງ chunk ຕ້ອງໄດ້ຮັບການກວດສອບ, ພຽງແຕ່ລະຫັດຕົ້ນຕໍ
ຖັນ ແລະ checksum ຖືກສົ່ງຜ່ານເຄືອຂ່າຍ, ບໍ່ແມ່ນແຖວທັງໝົດ. ຖ້າເປັນແຖວ
ພົບວ່າມີຄວາມແຕກຕ່າງກັນ, ແຖວທັງຫມົດຈະຖືກດຶງ, ແຕ່ບໍ່ແມ່ນກ່ອນ.
ໃຫ້ສັງເກດວ່າ algorithm ນີ້ຈະບໍ່ເຮັດວຽກຖ້າຫາກວ່າ chunking ຖັນ char ບ່ອນທີ່ຄ່າທັງຫມົດ
ເລີ່ມຕົ້ນດ້ວຍລັກສະນະດຽວກັນ. ໃນກໍລະນີດັ່ງກ່າວ, ເຄື່ອງມືຈະອອກແລະແນະນໍາໃຫ້ເລືອກເອົາ a
ສູດການຄິດໄລ່ທີ່ແຕກຕ່າງກັນ.
ໜຽວ
ຊອກຫາດັດຊະນີແລະຂຶ້ນດັດຊະນີໃນ nibbles ຂະຫນາດຄົງທີ່ຂອງແຖວ "--chunk-size",
ການນໍາໃຊ້ວິທີການທີ່ບໍ່ແມ່ນ backtracking (ເບິ່ງ pt-archiver ສໍາລັບການເພີ່ມເຕີມກ່ຽວກັບວິທີການນີ້). ມັນ
ແມ່ນຄ້າຍຄືກັນກັບ "Chunk", ແຕ່ແທນທີ່ຈະຄິດໄລ່ຂອບເຂດຊາຍແດນຂອງແຕ່ລະຄົນ
ຊິ້ນສ່ວນຂອງຕາຕະລາງໂດຍອີງໃສ່ດັດຊະນີ cardinality, ມັນໃຊ້ "LIMIT" ເພື່ອກໍານົດແຕ່ລະ nibble ຂອງ.
ຂອບເຂດຈໍາກັດເທິງ, ແລະຂອບເຂດຈໍາກັດເທິງຂອງ nibble ທີ່ຜ່ານມາເພື່ອກໍານົດຂອບເຂດຈໍາກັດຕ່ໍາ.
ມັນເຮັດວຽກຢູ່ໃນຂັ້ນຕອນ: ຄໍາຖາມຫນຶ່ງຊອກຫາແຖວທີ່ຈະກໍານົດເທິງຂອງ nibble ຕໍ່ໄປ
ຂອບເຂດ, ແລະການສອບຖາມຕໍ່ໄປ checksums nibble ທັງຫມົດ. ຖ້າ nibble ແຕກຕ່າງກັນ
ລະຫວ່າງຕົ້ນທາງແລະຈຸດຫມາຍປາຍທາງ, ມັນກວດກາເບິ່ງເສັ້ນໄຍແຖວຕໍ່ແຖວ, ຄືກັນກັບ "Chunk"
ບໍ່
GroupBy
ເລືອກຕາຕະລາງທັງໝົດຈັດກຸ່ມໂດຍຖັນທັງໝົດ, ດ້ວຍການເພີ່ມຖັນ COUNT(*).
ປຽບທຽບຖັນທັງໝົດ, ແລະຖ້າພວກມັນຄືກັນ, ປຽບທຽບຄ່າຂອງຖັນ COUNT(*) ກັບ
ກໍານົດຈໍານວນແຖວທີ່ຈະໃສ່ຫຼືລຶບເຂົ້າໄປໃນປາຍທາງ. ເຮັດວຽກຢູ່ໃນຕາຕະລາງ
ບໍ່ມີກະແຈຫຼັກ ຫຼື ດັດຊະນີທີ່ເປັນເອກະລັກ.
ນ້ໍາ
ເລືອກຕາຕະລາງທັງໝົດໃນສະຕຣີມໃຫຍ່ອັນດຽວ ແລະປຽບທຽບຖັນທັງໝົດ. ເລືອກທັງໝົດ
ຖັນ. ຫຼາຍປະສິດທິພາບຫນ້ອຍກ່ວາ algorithms ອື່ນໆ, ແຕ່ເຮັດວຽກໃນເວລາທີ່ບໍ່ມີ
ດັດຊະນີທີ່ເຫມາະສົມສໍາລັບພວກເຂົາທີ່ຈະໃຊ້.
ແຜນການໃນອະນາຄົດ
ຄວາມເປັນໄປໄດ້ສໍາລັບ algorithms ໃນອະນາຄົດແມ່ນ TempTable (ສິ່ງທີ່ຂ້ອຍເອີ້ນວ່າເດີມ - ລຸ່ມສຸດ
ໃນສະບັບກ່ອນຫນ້ານີ້ຂອງເຄື່ອງມືນີ້, DrillDown (ອັນທີ່ຂ້າພະເຈົ້າໃນເບື້ອງຕົ້ນເອີ້ນວ່າເທິງລົງລຸ່ມ), ແລະ
GroupByPrefix (ຄ້າຍກັບວິທີການເຮັດວຽກຕົວແທນ SqlYOG). ແຕ່ລະ algorithm ມີຈຸດແຂງ
ແລະຈຸດອ່ອນ. ຖ້າທ່ານຕ້ອງການປະຕິບັດເຕັກນິກທີ່ທ່ານມັກໃນການຄົ້ນຫາ
ຄວາມແຕກຕ່າງລະຫວ່າງສອງແຫຼ່ງຂໍ້ມູນໃນເຄື່ອງແມ່ຂ່າຍທີ່ແຕກຕ່າງກັນ, ຂ້ອຍເຕັມໃຈທີ່ຈະ
ຊ່ວຍເຫຼືອ. ສູດການຄິດໄລ່ປະຕິບັດຕາມການໂຕ້ຕອບທີ່ງ່າຍດາຍທີ່ເຮັດໃຫ້ມັນງ່າຍຕໍ່ການຂຽນ
ຂອງເຈົ້າເອງ.
ການປະມູນ ການຊິ້ງຂໍ້ມູນ
ການຊິງຄ໌ສອງທິດທາງເປັນລັກສະນະທົດລອງໃໝ່. ເພື່ອເຮັດໃຫ້ມັນເຮັດວຽກທີ່ເຊື່ອຖືໄດ້ມີ
ຂໍ້ຈໍາກັດທີ່ເຄັ່ງຄັດຈໍານວນຫນຶ່ງ:
* ເຮັດວຽກພຽງແຕ່ໃນເວລາທີ່ syncing ເຄື່ອງແມ່ຂ່າຍຫນຶ່ງກັບເຄື່ອງແມ່ຂ່າຍເອກະລາດອື່ນໆ
* ບໍ່ໄດ້ເຮັດວຽກໃນວິທີການໃດໆກັບການຈໍາລອງ
* ຮຽກຮ້ອງໃຫ້ຕາຕະລາງແມ່ນ chunkable ກັບ Chunk algorithm
* ບໍ່ແມ່ນ N-way, ພຽງແຕ່ເປັນສອງທິດທາງລະຫວ່າງສອງເຄື່ອງແມ່ຂ່າຍໃນເວລາດຽວ
* ບໍ່ໄດ້ຈັດການລຶບການປ່ຽນແປງ
ຕົວຢ່າງ, ສົມມຸດວ່າພວກເຮົາມີສາມເຄື່ອງແມ່ຂ່າຍ: c1, r1, r2. c1 ແມ່ນເຄື່ອງແມ່ຂ່າຍກາງ, a
pseudo-master ກັບເຄື່ອງແມ່ຂ່າຍອື່ນໆ (viz. r1 ແລະ r2 ບໍ່ແມ່ນສໍາລອງຂອງ c1). r1 ແລະ r2 ແມ່ນ
ເຊີບເວີທາງໄກ. ແຖວຢູ່ໃນຕາຕະລາງ foo ໄດ້ຖືກປັບປຸງແລະໃສ່ໃນເຄື່ອງແມ່ຂ່າຍທັງສາມແລະພວກເຮົາ
ຕ້ອງການ synchronize ການປ່ຽນແປງທັງຫມົດລະຫວ່າງເຄື່ອງແມ່ຂ່າຍທັງຫມົດ. ຕາຕະລາງ foo ມີຖັນ:
id int PRIMARY KEY
ts timestamp ອັບເດດອັດຕະໂນມັດ
ຊື່ varchar
ການຊົດເຊີຍການເພີ່ມອັດຕະໂນມັດຖືກນໍາໃຊ້ເພື່ອໃຫ້ແຖວໃຫມ່ຈາກເຄື່ອງແມ່ຂ່າຍໃດໆບໍ່ສ້າງຄວາມຂັດແຍ້ງ
ລະຫັດຫຼັກ (id) ຄ່າ. ໂດຍທົ່ວໄປ, ແຖວໃຫມ່, ຕາມທີ່ກໍານົດໂດຍຖັນ ts, ເອົາ
ກ່ອນໜ້າເມື່ອພົບແຖວດຽວກັນແຕ່ແຕກຕ່າງກັນໃນລະຫວ່າງການຊິງຄ໌ສອງທິດທາງ. "ຄືກັນ
ແຕ່ແຕກຕ່າງກັນ" ຫມາຍຄວາມວ່າສອງແຖວມີຄ່າຫຼັກ (id) ດຽວກັນແຕ່ແຕກຕ່າງກັນ
ຄ່າສໍາລັບຖັນອື່ນ, ເຊັ່ນ: ຖັນຊື່ໃນຕົວຢ່າງນີ້. ຄືກັນແຕ່ແຕກຕ່າງກັນ
ຂໍ້ຂັດແຍ່ງຖືກແກ້ໄຂໂດຍ "ຄວາມຂັດແຍ້ງ". ຂໍ້ຂັດແຍ່ງປຽບທຽບບາງຖັນຂອງການແຂ່ງຂັນ
ແຖວເພື່ອກໍານົດ "ຜູ້ຊະນະ". ແຖວທີ່ຊະນະກາຍເປັນແຫຼ່ງແລະມູນຄ່າຂອງມັນຖືກນໍາໃຊ້
ເພື່ອປັບປຸງແຖວອື່ນ.
ມີຄວາມແຕກຕ່າງເລັກນ້ອຍລະຫວ່າງສາມຖັນທີ່ໃຊ້ເພື່ອບັນລຸການຊິງຄ໌ສອງທິດທາງ
ທີ່ທ່ານຄວນຄຸ້ນເຄີຍກັບ: chunk column ("--chunk-column"), ຖັນປຽບທຽບ
("--columns"), ແລະຖັນຂໍ້ຂັດແຍ່ງ ("--conflict-column"). ຖັນ chunk ແມ່ນໃຊ້ພຽງແຕ່
ເພື່ອ chunk ຕາ ຕະ ລາງ; ຕົວຢ່າງ: "WHERE id >= 5 AND id < 10". Chunks ແມ່ນ checksummed ແລະເວລາໃດ
chunk checksums ເປີດເຜີຍຄວາມແຕກຕ່າງ, ເຄື່ອງມືເລືອກແຖວໃນ chunk ແລະ checksums
"--columns" ສໍາລັບແຕ່ລະແຖວ. ຖ້າຖັນ checksum ແຕກຕ່າງກັນ, ແຖວມີໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ
ຄ່າຖັນທີ່ຂັດແຍ່ງກັນ. ໃນ sync unidirectional ແບບດັ້ງເດີມ, ຂໍ້ຂັດແຍ່ງແມ່ນ moot
ຈຸດເນື່ອງຈາກວ່າມັນສາມາດໄດ້ຮັບການແກ້ໄຂພຽງແຕ່ໂດຍການປັບປຸງແຖວປາຍທາງທັງຫມົດທີ່ມີ
ຄ່າຂອງແຖວແຫຼ່ງ. ໃນ sync bidirectional, ແນວໃດກໍ່ຕາມ, "--conflict-column" (in
ສອດຄ່ອງກັບລາຍການທາງເລືອກ "--conflict-*" ອື່ນໆຂ້າງລຸ່ມນີ້) ແມ່ນປຽບທຽບເພື່ອກໍານົດວ່າອັນໃດ
ແຖວແມ່ນ "ຖືກຕ້ອງ" ຫຼື "ອະນຸຍາດ"; ແຖວນີ້ກາຍເປັນ "ແຫຼ່ງ".
ເພື່ອຊິງຄ໌ເຊີບເວີທັງສາມຢ່າງຄົບຖ້ວນ, ສອງແລ່ນຂອງ pt-table-sync ແມ່ນຕ້ອງການ. ທໍາອິດ
ດໍາເນີນການ syncs c1 ແລະ r1, ຫຼັງຈາກນັ້ນ syncs c1 ແລະ r2 ລວມທັງການປ່ຽນແປງໃດໆຈາກ r1. ໃນຈຸດນີ້ c1
ແລະ r2 ແມ່ນ sync ຢ່າງສົມບູນ, ແຕ່ r1 ຂາດການປ່ຽນແປງໃດໆຈາກ r2 ເພາະວ່າ c1 ບໍ່ໄດ້
ມີການປ່ຽນແປງເຫຼົ່ານີ້ເມື່ອມັນແລະ r1 ຖືກຊິງ. ດັ່ງນັ້ນການດໍາເນີນການທີສອງແມ່ນຈໍາເປັນທີ່ຈະ syncs ໄດ້
ເຄື່ອງແມ່ຂ່າຍໃນຄໍາສັ່ງດຽວກັນ, ແຕ່ເວລານີ້ເມື່ອ c1 ແລະ r1 ຖືກ synced r1 ໄດ້ຮັບການປ່ຽນແປງຂອງ r2.
ເຄື່ອງມືບໍ່ໄດ້ sync N-ways, ພຽງແຕ່ bidirectionally ລະຫວ່າງ DSN ທໍາອິດທີ່ໃຫ້ຢູ່ໃນ
ເສັ້ນຄໍາສັ່ງແລະແຕ່ລະ DSN ຕໍ່ມາ. ດັ່ງນັ້ນເຄື່ອງມືໃນຕົວຢ່າງນີ້ຈະຖືກແລ່ນ
ສອງຄັ້ງເຊັ່ນ:
pt-table-sync --bidirectional h=c1 h=r1 h=r2
ທາງເລືອກ "--bidirectional" ເປີດໃຊ້ຄຸນສົມບັດນີ້ແລະເຮັດໃຫ້ການກວດສອບສຸຂະພາບຕ່າງໆ
ປະຕິບັດ. ທ່ານຕ້ອງລະບຸທາງເລືອກອື່ນທີ່ບອກວິທີການແກ້ໄຂ pt-table-sync
ຂໍ້ຂັດແຍ່ງສໍາລັບແຖວດຽວກັນແຕ່ແຕກຕ່າງກັນ. ທາງເລືອກເຫຼົ່ານີ້ແມ່ນ:
* --conflict-column
* --conflict-ປຽບທຽບ
* --conflict-value
* --conflict-threshold
* --conflict-error"> (ທາງເລືອກ)
ໃຊ້ "--print" ເພື່ອທົດສອບຕົວເລືອກນີ້ກ່ອນ "--execute". ຄໍາສັ່ງ SQL ທີ່ພິມອອກຈະ
ມີຄໍາຄິດເຫັນທີ່ບອກວ່າຄໍາຖະແຫຼງທີ່ເປັນເຈົ້າພາບຈະຖືກປະຕິບັດຖ້າທ່ານໃຊ້
"-- ປະຕິບັດ".
ຫມາຍເຫດທາງດ້ານວິຊາການ: DSN ທໍາອິດແມ່ນສະເຫມີ "ຊ້າຍ" ເຄື່ອງແມ່ຂ່າຍແລະ DSN ອື່ນໆແມ່ນ
ສະເຫມີເຄື່ອງແມ່ຂ່າຍ "ທີ່ຖືກຕ້ອງ". ເນື່ອງຈາກວ່າເຄື່ອງແມ່ຂ່າຍສາມາດກາຍເປັນແຫຼ່ງຫຼືປາຍທາງຂອງມັນ
ສັບສົນທີ່ຈະຄິດວ່າພວກເຂົາເປັນ "src" ແລະ "dst". ເພາະສະນັ້ນ, ພວກມັນຖືກເອີ້ນວ່າໂດຍທົ່ວໄປ
ເປັນຊ້າຍແລະຂວາ. ມັນງ່າຍທີ່ຈະຈື່ຈໍາອັນນີ້ເພາະວ່າ DSN ທໍາອິດແມ່ນຢູ່ເບື້ອງຊ້າຍສະເຫມີ
ຂອງເຊີບເວີ DSNs ອື່ນໆຢູ່ໃນເສັ້ນຄໍາສັ່ງ.
ອອກ STATUS
ຕໍ່ໄປນີ້ແມ່ນສະຖານະການອອກ (ຍັງເອີ້ນວ່າຄ່າກັບຄືນ, ຫຼືລະຫັດກັບຄືນໄປບ່ອນ) ເມື່ອ pt-
table-sync ສໍາເລັດແລະອອກ.
ຄວາມຫມາຍສະຖານະ
============ ============================================ ===========
0 ຄວາມສຳເລັດ.
1 ຄວາມຜິດພາດພາຍໃນ.
2 ຢ່າງຫນ້ອຍຫນຶ່ງຕາຕະລາງແຕກຕ່າງກັນໃນຈຸດຫມາຍປາຍທາງ.
3 ການປະສົມຂອງ 1 ແລະ 2.
OPTIONS
ລະບຸຢ່າງໜ້ອຍໜຶ່ງໃນ "--print", "--execute", ຫຼື "--dry-run".
"--where" ແລະ "--replicate" ແມ່ນສະເພາະເຊິ່ງກັນແລະກັນ.
ເຄື່ອງມືນີ້ຍອມຮັບການໂຕ້ຖຽງແຖວຄໍາສັ່ງເພີ່ມເຕີມ. ອ້າງອີງເຖິງ "SYNOPSIS" ແລະການນໍາໃຊ້
ຂໍ້ມູນສໍາລັບລາຍລະອຽດ.
-- ສູດການຄິດໄລ່
ປະເພດ: ຊ່ອຍແນ່; ຄ່າເລີ່ມຕົ້ນ: Chunk, Nibble, GroupBy, Stream
ສູດການຄິດໄລ່ທີ່ຈະໃຊ້ເມື່ອປຽບທຽບຕາຕະລາງ, ຕາມລໍາດັບ.
ສໍາລັບແຕ່ລະຕາຕະລາງ, pt-table-sync ຈະກວດເບິ່ງວ່າຕາຕະລາງສາມາດຖືກ synced ກັບທີ່ກໍານົດໄວ້
ສູດການຄິດໄລ່ຕາມລໍາດັບທີ່ເຂົາເຈົ້າໄດ້ຖືກມອບໃຫ້. ສູດການຄິດໄລ່ທໍາອິດທີ່ສາມາດ sync ໄດ້
ຕາຕະລາງຖືກນໍາໃຊ້. ເບິ່ງ "ALGORITHMS".
--ຖາມຜ່ານ
ເຕືອນລະຫັດຜ່ານເມື່ອເຊື່ອມຕໍ່ກັບ MySQL.
--bidirectional
ເປີດໃຊ້ການຊິງຄ໌ສອງທິດທາງລະຫວ່າງໂຮສທຳອິດ ແລະໜ່ວຍຕໍ່ໄປ.
ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
--[ບໍ່]bin-log
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ບັນທຶກຂໍ້ມູນຖານສອງ ("SET SQL_LOG_BIN=1").
ການລະບຸ "--no-bin-log" ຈະ "SET SQL_LOG_BIN=0".
--buffer-in-mysql
ສັ່ງໃຫ້ MySQL buffer queries ໃນຫນ່ວຍຄວາມຈໍາຂອງມັນ.
ຕົວເລືອກນີ້ເພີ່ມ "SQL_BUFFER_RESULT" ທາງເລືອກໃນການສອບຖາມການປຽບທຽບ. ນີ້
ເຮັດໃຫ້ MySQL ປະຕິບັດການສອບຖາມແລະວາງໄວ້ໃນຕາຕະລາງຊົ່ວຄາວພາຍໃນ
ກ່ອນທີ່ຈະສົ່ງຜົນໄດ້ຮັບກັບຄືນໄປບ່ອນ pt-table-sync. ປະໂຫຍດຂອງຍຸດທະສາດນີ້ແມ່ນ
ວ່າ pt-table-sync ສາມາດດຶງແຖວຕາມຄວາມຕ້ອງການໂດຍບໍ່ຕ້ອງໃຊ້ຫນ່ວຍຄວາມຈໍາຫຼາຍພາຍໃນ
ຂະບວນການ Perl, ໃນຂະນະທີ່ປ່ອຍ locks ໃນຕາຕະລາງ MySQL (ເພື່ອຫຼຸດຜ່ອນການຂັດແຍ້ງກັບ
ຄໍາຖາມອື່ນໆ). ຂໍ້ເສຍແມ່ນວ່າມັນໃຊ້ຫນ່ວຍຄວາມຈໍາຫຼາຍໃນເຄື່ອງແມ່ຂ່າຍ MySQL
ແທນທີ່ຈະເປັນ.
ທ່ານອາດຈະຕ້ອງການປ່ອຍໃຫ້ "--[no]buffer-to-client" ຖືກເປີດໃຊ້ຄືກັນ, ເພາະວ່າ buffering
ເຂົ້າໄປໃນຕາຕະລາງ temp ແລະຫຼັງຈາກນັ້ນດຶງມັນທັງຫມົດເຂົ້າໄປໃນຄວາມຊົງຈໍາຂອງ Perl ແມ່ນອາດຈະເປັນເລື່ອງໂງ່
ສິ່ງທີ່ຕ້ອງເຮັດ. ທາງເລືອກນີ້ແມ່ນເປັນປະໂຫຍດທີ່ສຸດສໍາລັບ algorithms GroupBy ແລະ Stream, ເຊິ່ງ
ອາດຈະດຶງຂໍ້ມູນຈໍານວນຫລາຍຈາກເຄື່ອງແມ່ຂ່າຍ.
--[ບໍ່]buffer-to-client
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ເອົາແຖວຫນຶ່ງຕໍ່ຫນຶ່ງຈາກ MySQL ໃນຂະນະທີ່ປຽບທຽບ.
ຕົວເລືອກນີ້ເປີດໃຊ້ "mysql_use_result" ເຊິ່ງເຮັດໃຫ້ MySQL ຖືແຖວທີ່ເລືອກໄວ້
ເຄື່ອງແມ່ຂ່າຍຈົນກ່ວາເຄື່ອງມືດຶງພວກມັນ. ນີ້ອະນຸຍາດໃຫ້ເຄື່ອງມືທີ່ຈະໃຊ້ຫນ່ວຍຄວາມຈໍາຫນ້ອຍແຕ່
ອາດເຮັດໃຫ້ແຖວຖືກລັອກຢູ່ໃນເຊີບເວີດົນຂຶ້ນ.
ຖ້າຕົວເລືອກນີ້ຖືກປິດໃຊ້ງານໂດຍການລະບຸ "--no-buffer-to-client" ຫຼັງຈາກນັ້ນ
"mysql_store_result" ຖືກນໍາໃຊ້ເຊິ່ງເຮັດໃຫ້ MySQL ສົ່ງແຖວທີ່ເລືອກທັງຫມົດໄປຫາເຄື່ອງມື
ດຽວນີ້. ນີ້ອາດຈະເຮັດໃຫ້ຜົນໄດ້ຮັບ "ຕົວກະພິບ" ຖືກເປີດເປັນເວລາສັ້ນໆ
ໃນເຊີບເວີ, ແຕ່ຖ້າຕາຕະລາງມີຂະຫນາດໃຫຍ່, ມັນອາດຈະໃຊ້ເວລາດົນ, ແລະໃຊ້
ຄວາມຊົງຈໍາທັງຫມົດຂອງທ່ານ.
ສໍາລັບຂະຫນາດຂໍ້ມູນທີ່ບໍ່ແມ່ນເລື່ອງເລັກໆນ້ອຍໆ, ທ່ານຕ້ອງການປ່ອຍໃຫ້ທາງເລືອກນີ້ເປີດໃຊ້ງານ.
ຕົວເລືອກນີ້ຖືກປິດໃຊ້ງານເມື່ອ "--bidirectional" ຖືກນໍາໃຊ້.
--ຊຸດຕົວອັກສອນ
ຮູບແບບສັ້ນ: -A; ປະເພດ: string
ຕັ້ງຕົວອັກສອນເລີ່ມຕົ້ນ. ຖ້າຄ່າແມ່ນ utf8, ຕັ້ງ binmode ຂອງ Perl ໃນ STDOUT ເປັນ utf8,
ຜ່ານຕົວເລືອກ mysql_enable_utf8 ໄປ DBD::mysql, ແລະແລ່ນ SET NAMES UTF8 ຫຼັງຈາກ.
ເຊື່ອມຕໍ່ກັບ MySQL. ຄ່າອື່ນໃດກຳນົດ binmode ໃນ STDOUT ໂດຍບໍ່ມີຊັ້ນ utf8,
ແລະດໍາເນີນການ SET NAMES ຫຼັງຈາກເຊື່ອມຕໍ່ກັບ MySQL.
--[ບໍ່]ຕາຕະລາງກວດເດັກນ້ອຍ
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ກວດເບິ່ງວ່າ "--execute" ຈະສົ່ງຜົນກະທົບຕໍ່ຕາຕະລາງເດັກນ້ອຍຫຼືບໍ່. ເມື່ອ "-- ທົດແທນ",
"--replicate", ຫຼື "--sync-to-master" ຖືກລະບຸ, ເຄື່ອງມືອາດຈະ sync ຕາຕະລາງໂດຍໃຊ້
"REPLACE" ຄໍາຖະແຫຼງການ. ຖ້າຕາຕະລາງທີ່ຖືກຊິ້ງມີຕາຕະລາງເດັກນ້ອຍທີ່ມີ "ON DELETE
CASCADE", "ON UPDATE CASCADE", ຫຼື "ON UPDATE SET NULL", ເຄື່ອງມືພິມຂໍ້ຜິດພາດແລະ
ຂ້າມຕາຕະລາງເພາະວ່າ "REPLACE" ກາຍເປັນ "DELETE" ຈາກນັ້ນ "INSERT", ດັ່ງນັ້ນ "DELETE" ຈະ.
cascade ໄປຫາຕາຕະລາງເດັກນ້ອຍແລະລຶບແຖວຂອງມັນ. ໃນກໍລະນີຮ້າຍແຮງທີ່ສຸດ, ນີ້ສາມາດລຶບໄດ້
ແຖວທັງໝົດໃນຕາຕະລາງເດັກນ້ອຍ!
ລະບຸ "--no-check-child-tables" ເພື່ອປິດການກວດສອບນີ້. ເພື່ອຫຼີກເວັ້ນການຢ່າງສົມບູນ
ຜົນກະທົບຕໍ່ຕາຕະລາງເດັກນ້ອຍ, ຍັງລະບຸ "--no-foreign-key-checks" ດັ່ງນັ້ນ MySQL ຈະບໍ່.
cascade ການດໍາເນີນງານໃດໆຈາກພໍ່ແມ່ໄປຫາຕາຕະລາງເດັກນ້ອຍ.
ການກວດສອບນີ້ແມ່ນຖືກປະຕິບັດກ່ອນພຽງແຕ່ຖ້າ "--execute" ແລະຫນຶ່ງໃນ "--replace", "--replicate", ຫຼື
"--sync-to-master" ຖືກລະບຸ. "--print" ບໍ່ໄດ້ກວດເບິ່ງຕາຕະລາງເດັກນ້ອຍ.
ຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດພຽງແຕ່ພິມຕາຕະລາງເດັກນ້ອຍທໍາອິດທີ່ພົບເຫັນດ້ວຍ "ON DELETE CASCADE",
"ON UPDATE CASCADE", ຫຼື "ON UPDATE SET NULL" ຂໍ້ຈໍາກັດຂອງກະແຈຕ່າງປະເທດ. ອາດຈະມີ
ຕາຕະລາງເດັກນ້ອຍອື່ນໆທີ່ໄດ້ຮັບຜົນກະທົບ.
--[ບໍ່]check-master
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ດ້ວຍ "--sync-to-master", ພະຍາຍາມກວດສອບວ່າແມ່ບົດທີ່ກວດພົບແມ່ນແມ່ບົດທີ່ແທ້ຈິງ.
--[ບໍ່]check-slave
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ກວດເບິ່ງວ່າເຄື່ອງແມ່ຂ່າຍປາຍທາງເປັນສໍາລອງຫຼືບໍ່.
ຖ້າເຄື່ອງແມ່ຂ່າຍປາຍທາງເປັນທາດ, ໂດຍທົ່ວໄປແລ້ວມັນບໍ່ປອດໄພທີ່ຈະປ່ຽນແປງມັນ.
ຢ່າງໃດກໍຕາມ, ບາງຄັ້ງທ່ານຕ້ອງ; "--replace" ຈະບໍ່ເຮັດວຽກເວັ້ນເສຍແຕ່ວ່າມີດັດຊະນີທີ່ເປັນເອກະລັກ,
ຕົວຢ່າງ, ດັ່ງນັ້ນທ່ານບໍ່ສາມາດປ່ຽນແປງຕົ້ນສະບັບໃນສະຖານະການນັ້ນ. ໂດຍຄ່າເລີ່ມຕົ້ນ pt-
table-sync ຈະຈົ່ມຖ້າທ່ານພະຍາຍາມປ່ຽນຂໍ້ມູນໃນ slave. ລະບຸ
"--no-check-slave" ເພື່ອປິດການກວດສອບນີ້. ໃຊ້ມັນຢູ່ໃນຄວາມສ່ຽງຂອງທ່ານເອງ.
--[ບໍ່] check-triggers
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ກວດເບິ່ງວ່າບໍ່ມີ triggers ຖືກກໍານົດຢູ່ໃນຕາຕະລາງປາຍທາງ.
Triggers ໄດ້ຖືກນໍາສະເຫນີໃນ MySQL v5.0.2, ດັ່ງນັ້ນສໍາລັບຮຸ່ນເກົ່າທາງເລືອກນີ້ບໍ່ມີ
ຜົນກະທົບເນື່ອງຈາກວ່າ triggers ຈະບໍ່ຖືກກວດສອບ.
--chunk-ຖັນ
ປະເພດ: string
ຕັດຕາຕະລາງຢູ່ໃນຖັນນີ້.
--chunk-index
ປະເພດ: string
ຕັດຕາຕະລາງໂດຍໃຊ້ດັດຊະນີນີ້.
--chunk-size
ປະເພດ: ຊ່ອຍແນ່; ຄ່າເລີ່ມຕົ້ນ: 1000
ຈຳນວນແຖວ ຫຼືຂະໜາດຂໍ້ມູນຕໍ່ຊຸດ.
ຂະຫນາດຂອງແຕ່ລະ chunk ຂອງແຖວສໍາລັບ "Chunk" ແລະ "Nibble" algorithms. ຂະຫນາດສາມາດ
ເປັນຈໍານວນແຖວ, ຫຼືຂະຫນາດຂໍ້ມູນ. ຂະໜາດຂໍ້ມູນຖືກລະບຸດ້ວຍຄຳຕໍ່ທ້າຍຂອງ
k=kibibytes, M=mebibytes, G=gibibytes. ຂະໜາດຂໍ້ມູນຖືກປ່ຽນເປັນຈຳນວນແຖວ
ໂດຍແບ່ງຕາມຄວາມຍາວຂອງແຖວສະເລ່ຍ.
--ຖັນ
ຮູບແບບສັ້ນ: -c; ປະເພດ: array
ປຽບທຽບລາຍຊື່ຖັນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ.
--config
ປະເພດ: Array
ອ່ານລາຍຊື່ໄຟລ໌ config ທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດນີ້; ຖ້າລະບຸ, ນີ້ຈະຕ້ອງເປັນອັນທໍາອິດ
ທາງເລືອກໃນແຖວຄໍາສັ່ງ.
--conflict-column
ປະເພດ: string
ປຽບທຽບຖັນນີ້ເມື່ອແຖວຂັດກັນໃນລະຫວ່າງການຊິງຄ໌ "--bidirectional".
ເມື່ອພົບແຖວດຽວກັນແຕ່ແຕກຕ່າງກັນ, ຄ່າຂອງຖັນນີ້ຈາກແຕ່ລະແຖວແມ່ນ
ປຽບທຽບຕາມ "--conflict-comparison", "--conflict-value" ແລະ
"--conflict-threshold" ເພື່ອກໍານົດວ່າແຖວໃດມີຂໍ້ມູນທີ່ຖືກຕ້ອງແລະກາຍເປັນ
ແຫຼ່ງ. ຖັນສາມາດເປັນປະເພດໃດກໍໄດ້ທີ່ເໝາະສົມ
"--conflict-comparison" (ນີ້ແມ່ນເກືອບທຸກປະເພດຍົກເວັ້ນ, ສໍາລັບການຍົກຕົວຢ່າງ, blobs).
ຕົວເລືອກນີ້ໃຊ້ໄດ້ກັບ "--bidirectional". ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ
ຂໍ້ມູນຂ່າວສານ.
--conflict-ປຽບທຽບ
ປະເພດ: string
ເລືອກ "--conflict-column" ທີ່ມີຄຸນສົມບັດນີ້ເປັນແຫຼ່ງ.
ຕົວເລືອກມີຜົນຕໍ່ຄ່າ "--conflict-column" ຈາກແຖວທີ່ຂັດແຍ່ງກັນແນວໃດ
ປຽບທຽບ. ການປຽບທຽບທີ່ເປັນໄປໄດ້ແມ່ນໜຶ່ງໃນ MAGIC_comparisons ເຫຼົ່ານີ້:
ໃໝ່ສຸດ|ເກົ່າສຸດ|ໃຫຍ່ສຸດ|ໜ້ອຍສຸດ|ເທົ່າກັນ|ກົງກັນ
ການປຽບທຽບເລືອກແຖວດ້ວຍ
============================================================= =================
ໃໝ່ລ່າສຸດ ໃໝ່ລ່າສຸດ -conflict-column value
ເກົ່າແກ່ທີ່ສຸດ Oldest temporal --conflict-column value
greatest ຕົວເລກທີ່ຍິ່ງໃຫຍ່ທີ່ສຸດ "--conflict-column value
ຕົວເລກໜ້ອຍສຸດ --conflict-column value
ເທົ່າກັບ --conflict-column value ເທົ່າກັບ --conflict-value
ຈັບຄູ່ --conflict-column value matching Perl regex pattern
--conflict-value
ຕົວເລືອກນີ້ໃຊ້ໄດ້ກັບ "--bidirectional". ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ
ຂໍ້ມູນຂ່າວສານ.
--ຄວາມຂັດແຍ່ງຜິດພາດ
ປະເພດ: ຊ່ອຍແນ່; ຄ່າເລີ່ມຕົ້ນ: ເຕືອນ
ວິທີການລາຍງານຂໍ້ຂັດແຍ່ງທີ່ບໍ່ສາມາດແກ້ໄຂໄດ້ແລະຄວາມຜິດພາດຂອງຂໍ້ຂັດແຍ່ງ
ຕົວເລືອກນີ້ປ່ຽນແປງວິທີທີ່ຜູ້ໃຊ້ໄດ້ຮັບການແຈ້ງເຕືອນເມື່ອຂໍ້ຂັດແຍ່ງບໍ່ສາມາດແກ້ໄຂໄດ້ ຫຼື
ເຮັດໃຫ້ເກີດຄວາມຜິດພາດບາງປະເພດ. ຄ່າທີ່ເປັນໄປໄດ້ແມ່ນ:
* ເຕືອນ: ພິມຄໍາເຕືອນໃຫ້ STDERR ກ່ຽວກັບຂໍ້ຂັດແຍ່ງທີ່ບໍ່ສາມາດແກ້ໄຂໄດ້
* die: ຕາຍ, ຢຸດການຊິງຄ໌, ແລະພິມຄຳເຕືອນໃຫ້ STDERR
ຕົວເລືອກນີ້ໃຊ້ໄດ້ກັບ "--bidirectional". ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ
ຂໍ້ມູນຂ່າວສານ.
--conflict-threshold
ປະເພດ: string
ຈຳນວນທີ່ໜຶ່ງ "--conflict-column" ຕ້ອງເກີນອັນອື່ນ.
"--conflict-threshold" ປ້ອງກັນບໍ່ໃຫ້ຂໍ້ຂັດແຍ່ງໄດ້ຮັບການແກ້ໄຂຖ້າຫາກວ່າຢ່າງແທ້ຈິງ
ຄວາມແຕກຕ່າງລະຫວ່າງສອງຄ່າ "--conflict-column" ແມ່ນຫນ້ອຍກວ່າຈໍານວນນີ້. ສໍາລັບ
ຕົວຢ່າງ, ຖ້າສອງ "--conflict-column" ມີມູນຄ່າ timestamp "2009-12-01 12:00:00" ແລະ
" 2009-12-01 12:05:00 " ຄວາມແຕກຕ່າງແມ່ນ 5 ນາທີ. ຖ້າ "--conflict-threshold" ຖືກຕັ້ງ
ເປັນ "5m" ຄວາມຂັດແຍ້ງຈະຖືກແກ້ໄຂ, ແຕ່ຖ້າ "--conflict-threshold" ຖືກຕັ້ງເປັນ "6m"
ຂໍ້ຂັດແຍ່ງຈະແກ້ໄຂບໍ່ໄດ້ເພາະວ່າຄວາມແຕກຕ່າງບໍ່ໃຫຍ່ກວ່າຫຼືເທົ່າທຽມກັນ
ເຖິງ 6 ນາທີ. ໃນກໍລະນີສຸດທ້າຍນີ້, "--conflict-error" ຈະລາຍງານຄວາມລົ້ມເຫຼວ.
ຕົວເລືອກນີ້ໃຊ້ໄດ້ກັບ "--bidirectional". ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ
ຂໍ້ມູນຂ່າວສານ.
--conflict-value
ປະເພດ: string
ໃຊ້ຄ່ານີ້ສໍາລັບ "--conflict-comparison".
ຕົວເລືອກນີ້ໃຫ້ຄ່າສໍາລັບ "ເທົ່າກັບ" ແລະ "ກົງກັນ" "--conflict-comparison".
ຕົວເລືອກນີ້ໃຊ້ໄດ້ກັບ "--bidirectional". ເບິ່ງ "BIDIRECTIONAL SYNCING" ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ
ຂໍ້ມູນຂ່າວສານ.
--ຖານຂໍ້ມູນ
ຮູບແບບສັ້ນ: -d; ປະເພດ: hash
ຊິງຄ໌ພຽງແຕ່ລາຍຊື່ຖານຂໍ້ມູນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ.
ການຮ້ອງຂໍທົ່ວໄປແມ່ນການຊິງຕາຕະລາງຈາກຖານຂໍ້ມູນຫນຶ່ງກັບຕາຕະລາງຈາກຖານຂໍ້ມູນອື່ນ
ຢູ່ໃນເຄື່ອງແມ່ຂ່າຍດຽວກັນຫຼືທີ່ແຕກຕ່າງກັນ. ອັນນີ້ຍັງເປັນໄປບໍ່ໄດ້. "--databases" ຈະບໍ່ເຮັດ
ມັນ, ແລະທ່ານບໍ່ສາມາດເຮັດມັນກັບສ່ວນ D ຂອງ DSN ບໍ່ວ່າຈະຍ້ອນວ່າບໍ່ມີ a
ຊື່ຕາຕະລາງມັນສົມມຸດວ່າເຄື່ອງແມ່ຂ່າຍທັງຫມົດຄວນຈະຖືກ synced ແລະສ່ວນ D ຄວບຄຸມເທົ່ານັ້ນ
ຖານຂໍ້ມູນເລີ່ມຕົ້ນຂອງການເຊື່ອມຕໍ່.
--defaults-file
ຮູບແບບສັ້ນ: -F; ປະເພດ: string
ພຽງແຕ່ອ່ານຕົວເລືອກ mysql ຈາກໄຟລ໌ທີ່ໃຫ້. ທ່ານຕ້ອງໃຫ້ຊື່ເສັ້ນທາງຢ່າງແທ້ຈິງ.
-- ແລ່ນແຫ້ງ
ວິເຄາະ, ຕັດສິນໃຈ algorithm sync ທີ່ຈະນໍາໃຊ້, ພິມແລະອອກ.
ຫມາຍເຖິງ "--verbose" ເພື່ອໃຫ້ທ່ານສາມາດເບິ່ງຜົນໄດ້ຮັບ. ຜົນໄດ້ຮັບແມ່ນຢູ່ໃນຜົນຜະລິດດຽວກັນ
ຮູບແບບທີ່ທ່ານຈະເຫັນຈາກການໃຊ້ເຄື່ອງມືໃນຕົວຈິງ, ແຕ່ວ່າຈະມີສູນສໍາລັບການ
ແຖວທີ່ໄດ້ຮັບຜົນກະທົບ. ນີ້ແມ່ນຍ້ອນວ່າເຄື່ອງມືປະຕິບັດຕົວຈິງ, ແຕ່ຢຸດກ່ອນທີ່ມັນ
ປຽບທຽບຂໍ້ມູນໃດນຶ່ງ ແລະສົ່ງຄືນຄ່າສູນ. ສູນບໍ່ໄດ້ຫມາຍຄວາມວ່າບໍ່ມີການປ່ຽນແປງ
ທີ່ຈະເຮັດ.
-- ເຄື່ອງຈັກ
ຮູບແບບສັ້ນ: -e; ປະເພດ: hash
ຊິ້ງສະເພາະລາຍການເຄື່ອງເກັບຂໍ້ມູນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ.
-- ປະຕິບັດ
ດໍາເນີນການສອບຖາມເພື່ອເຮັດໃຫ້ຕາຕະລາງມີຂໍ້ມູນດຽວກັນ.
ຕົວເລືອກນີ້ເຮັດໃຫ້ pt-table-sync ຕົວຈິງແລ້ວ sync ຂໍ້ມູນຕາຕະລາງໂດຍການດໍາເນີນການສອບຖາມທັງຫມົດ
ທີ່ມັນສ້າງຂຶ້ນເພື່ອແກ້ໄຂຄວາມແຕກຕ່າງຂອງຕາຕະລາງ. ດັ່ງນັ້ນ, ໄດ້ ຕາຕະລາງ ຈະ be ປ່ຽນ!
ແລະເວັ້ນເສຍແຕ່ວ່າທ່ານຍັງລະບຸ "--verbose", ການປ່ຽນແປງຈະຖືກເຮັດຢ່າງງຽບໆ. ຖ້ານີ້
ບໍ່ແມ່ນສິ່ງທີ່ທ່ານຕ້ອງການ, ເບິ່ງ "--print" ຫຼື "--dry-run".
--ອະທິບາຍ-ເຈົ້າພາບ
ພິມຂໍ້ມູນການເຊື່ອມຕໍ່ແລະອອກ.
ພິມອອກບັນຊີລາຍຊື່ຂອງເຈົ້າພາບທີ່ pt-table-sync ຈະເຊື່ອມຕໍ່, ມີທັງຫມົດຕ່າງໆ
ທາງເລືອກການເຊື່ອມຕໍ່, ແລະອອກ.
--float-precision
ປະເພດ: int
ຄວາມຊັດເຈນສໍາລັບການປ່ຽນຕົວເລກ "FLOAT" ແລະ "DOUBLE" ເປັນສະຕຣິງ. ເຮັດໃຫ້ເກີດ FLOAT ແລະ
ຄ່າສອງເທົ່າທີ່ຈະຖືກປັດເປັນຕົວເລກທີ່ລະບຸໄວ້ຫຼັງຈາກຈຸດທົດສະນິຍົມ,
ກັບ ຮອບ() ຟັງຊັນໃນ MySQL. ນີ້ສາມາດຊ່ວຍຫຼີກເວັ້ນການ checksum ບໍ່ກົງກັນເນື່ອງຈາກ
ການສະແດງຈຸດລອຍທີ່ແຕກຕ່າງກັນຂອງຄ່າດຽວກັນຢູ່ໃນ MySQL ທີ່ແຕກຕ່າງກັນ
ລຸ້ນ ແລະຮາດແວ. ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ມີການຮວບຮວມ; ຄ່າຖືກປ່ຽນເປັນ
ຊ່ອຍແນ່ໂດຍ CONCAT() ຟັງຊັນ, ແລະ MySQL ເລືອກຕົວແທນສະຕຣິງ. ຖ້າເຈົ້າ
ລະບຸຄ່າຂອງ 2, ຕົວຢ່າງ, ຫຼັງຈາກນັ້ນຄ່າ 1.008 ແລະ 1.009 ຈະຖືກປັດເປັນ.
1.01, ແລະຈະ checksum ເທົ່າກັບ.
--[ບໍ່]ການກວດກາຕ່າງປະເທດ
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ເປີດໃຊ້ການກວດສອບກະແຈຕ່າງປະເທດ ("SET FOREIGN_KEY_CHECKS=1").
ການລະບຸ "--no-foreign-key-checks" ຈະ "SET FOREIGN_KEY_CHECKS=0".
-- ຟັງຊັນ
ປະເພດ: string
ຟັງຊັນ hash ໃດທີ່ທ່ານຕ້ອງການໃຊ້ສໍາລັບ checksums.
ຄ່າເລີ່ມຕົ້ນແມ່ນ "CRC32". ທາງເລືອກທີ່ດີອື່ນໆລວມມີ "MD5" ແລະ "SHA1". ຖ້າເຈົ້າມີ
ຕິດຕັ້ງ "FNV_64" ຟັງຊັນທີ່ຜູ້ໃຊ້ກໍານົດ, "pt-table-sync" ຈະກວດພົບມັນແລະ
ມັກໃຊ້ມັນ, ເພາະວ່າມັນໄວກວ່າຕົວເຄື່ອງ. ນອກນັ້ນທ່ານຍັງສາມາດນໍາໃຊ້
MURMUR_HASH ຖ້າເຈົ້າໄດ້ຕິດຕັ້ງຟັງຊັນທີ່ຜູ້ໃຊ້ກຳນົດໄວ້. ທັງສອງນີ້ແມ່ນ
ແຈກຢາຍກັບ Maatkit. ເບິ່ງ pt-table-checksum ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມແລະດັດຊະນີ.
- ຊ່ວຍ
ສະແດງການຊ່ວຍເຫຼືອ ແລະອອກ.
--[ບໍ່] hex-blob
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ຖັນ "HEX()" "BLOB", "TEXT" ແລະ "BINARY".
ເມື່ອຂໍ້ມູນແຖວຈາກແຫຼ່ງຖືກດຶງມາເພື່ອສ້າງແບບສອບຖາມເພື່ອຊິງຂໍ້ມູນ (ເຊັ່ນ:
ຄໍາຖາມທີ່ເຫັນດ້ວຍ "--print" ແລະດໍາເນີນການໂດຍ "--execute"), ຖັນສອງຖືກຫໍ່ໄວ້.
in HEX() ດັ່ງນັ້ນຂໍ້ມູນຖານສອງບໍ່ໄດ້ຜະລິດຄໍາຖະແຫຼງ SQL ທີ່ບໍ່ຖືກຕ້ອງ. ເຈົ້າສາມາດ
ປິດການທໍາງານທາງເລືອກນີ້ແຕ່ທ່ານອາດຈະບໍ່ຄວນ.
-ເຈົ້າພາບ
ຮູບແບບສັ້ນ: -h; ປະເພດ: string
ເຊື່ອມຕໍ່ຫາເຈົ້າພາບ.
--ignore-ຖັນ
ປະເພດ: Hash
ບໍ່ສົນໃຈລາຍການທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດຂອງຊື່ຖັນໃນການປຽບທຽບ.
ຕົວເລືອກນີ້ເຮັດໃຫ້ຖັນບໍ່ຖືກປຽບທຽບ. ຢ່າງໃດກໍຕາມ, ຖ້າແຖວຖືກກໍານົດ
ແຕກຕ່າງກັນລະຫວ່າງຕາຕະລາງ, ຖັນທັງໝົດໃນແຖວນັ້ນຈະຖືກຊິ້ງ, ໂດຍບໍ່ສົນເລື່ອງ. (ມັນບໍ່ແມ່ນ
ໃນປັດຈຸບັນເປັນໄປໄດ້ທີ່ຈະຍົກເວັ້ນຄໍລໍາຈາກຂະບວນການ sync ຕົວຂອງມັນເອງ, ພຽງແຕ່ຈາກ
ການປຽບທຽບ.)
--ignore-ຖານຂໍ້ມູນ
ປະເພດ: Hash
ບໍ່ສົນໃຈລາຍຊື່ຖານຂໍ້ມູນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດນີ້.
(ຖານຂໍ້ມູນລະບົບເຊັ່ນ: information_schema ແລະ performance_schema ຖືກລະເລີຍໂດຍ
ເລີ່ມຕົ້ນ)
--ລະເລີຍເຄື່ອງຈັກ
ປະເພດ: Hash; ຄ່າເລີ່ມຕົ້ນ: FEDERATED,MRG_MyISAM
ບໍ່ສົນໃຈລາຍການເຄື່ອງເກັບຂໍ້ມູນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດນີ້.
--ignore-ຕາຕະລາງ
ປະເພດ: Hash
ບໍ່ສົນໃຈລາຍຊື່ຕາຕະລາງທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດນີ້.
ຊື່ຕາຕະລາງອາດມີຄຸນສົມບັດກັບຊື່ຖານຂໍ້ມູນ.
--ignore-tables-regex
ປະເພດ: ຊ່ອຍແນ່; ກຸ່ມ: ການກັ່ນຕອງ
ບໍ່ສົນໃຈຕາຕະລາງທີ່ມີຊື່ກົງກັບ Perl regex.
--[ບໍ່]index-hint
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ເພີ່ມຄໍາແນະນໍາຂອງ FORCE/USE INDEX ເຂົ້າໃນການສອບຖາມຂອງ chunk ແລະແຖວ.
ໂດຍຄ່າເລີ່ມຕົ້ນ "pt-table-sync" ເພີ່ມຄໍາແນະນໍາ FORCE/USE INDEX ໃຫ້ກັບແຕ່ລະຄໍາຖະແຫຼງທີ່ SQL ບັງຄັບ.
MySQL ເຂົ້າໄປໃນການນໍາໃຊ້ດັດຊະນີເລືອກໂດຍວິທີການ sync ຫຼືລະບຸໄວ້ໂດຍ
"--chunk-index". ນີ້ແມ່ນປົກກະຕິແລ້ວເປັນສິ່ງທີ່ດີ, ແຕ່ໃນກໍລະນີທີ່ຫາຍາກ, ດັດຊະນີອາດຈະບໍ່ເປັນ
ທີ່ດີທີ່ສຸດສໍາລັບການສອບຖາມເພື່ອໃຫ້ທ່ານສາມາດສະກັດກັ້ນຄໍາແນະນໍາດັດສະນີໂດຍການລະບຸ
"--no-index-hint" ແລະໃຫ້ MySQL ເລືອກດັດສະນີ.
ອັນນີ້ບໍ່ມີຜົນຕໍ່ກັບການສອບຖາມທີ່ພິມໂດຍ "--print"; ມັນມີຜົນກະທົບພຽງແຕ່ chunk ແລະ
ແຖວສອບຖາມທີ່ "pt-table-sync" ໃຊ້ເພື່ອເລືອກ ແລະປຽບທຽບແຖວ.
--ລັອກ
ປະເພດ: int
ຕາຕະລາງລັອກ: 0=none, 1=ຕໍ່ວົງຈອນການຊິງຄ໌, 2=ຕໍ່ຕາຕະລາງ, ຫຼື 3=ທົ່ວໂລກ.
ອັນນີ້ໃຊ້ "LOCK Tables". ນີ້ສາມາດຊ່ວຍປ້ອງກັນບໍ່ໃຫ້ຕາຕະລາງຖືກປ່ຽນແປງໃນຂະນະທີ່ທ່ານຢູ່
ກວດສອບພວກເຂົາ. ຄ່າທີ່ເປັນໄປໄດ້ມີດັ່ງນີ້:
VALUE ຄວາມຫມາຍ
============================================================= ==========
0 ຢ່າປິດໂຕະ.
1 ລັອກແລະປົດລັອກຫນຶ່ງຄັ້ງຕໍ່ວົງຈອນການຊິງ (ຕາມການປະຕິບັດ
ໂດຍລະບົບ syncing). ນີ້ແມ່ນ granular ທີ່ສຸດ
ລະດັບການລັອກທີ່ມີຢູ່. ສໍາລັບຕົວຢ່າງ, Chunk
algorithm ຈະລັອກແຕ່ລະ chunk ຂອງ C ແຖວ, ແລະຫຼັງຈາກນັ້ນ
ປົດລັອກໃຫ້ເຂົາເຈົ້າຖ້າຫາກວ່າພວກເຂົາເຈົ້າແມ່ນຄືກັນໃນແຫຼ່ງແລະ
ຈຸດໝາຍປາຍທາງ, ກ່ອນທີ່ຈະກ້າວໄປສູ່ຈຸດໝາຍຕໍ່ໄປ.
2 ລັອກແລະປົດລັອກກ່ອນແລະຫຼັງຈາກແຕ່ລະຕາຕະລາງ.
3 Lock ແລະປົດລັອກຫນຶ່ງຄັ້ງສໍາລັບທຸກເຄື່ອງແມ່ຂ່າຍ (DSN) ຊິງ, ກັບ
ຄ .
ສໍາລອງການຈໍາລອງຈະບໍ່ຖືກລັອກຖ້າ "--replicate" ຫຼື "--sync-to-master" ແມ່ນ
ລະບຸໄວ້, ເນື່ອງຈາກວ່າໃນທິດສະດີ locking ຕາຕະລາງກ່ຽວກັບແມ່ບົດຄວນປ້ອງກັນການປ່ຽນແປງໃດໆ
ຈາກການຈັດຕັ້ງ. (ເຈົ້າຍັງບໍ່ໄດ້ປ່ຽນຂໍ້ມູນໃນສໍາລອງຂອງເຈົ້າ, ແມ່ນບໍ?) ຖ້າ "--wait" ແມ່ນ
ໃຫ້, ຕົ້ນສະບັບ (ແຫຼ່ງ) ໄດ້ຖືກລັອກແລະຫຼັງຈາກນັ້ນເຄື່ອງມືລໍຖ້າສໍາລັບສໍາລອງທີ່ຈະຈັບເຖິງ
ໄປຫານາຍກ່ອນທີ່ຈະສືບຕໍ່.
ຖ້າ "--transaction" ຖືກລະບຸ, "LOCK TABLES" ບໍ່ໄດ້ຖືກນໍາໃຊ້. ແທນທີ່ຈະ, ລັອກແລະປົດລັອກ
ຖືກປະຕິບັດໂດຍການເລີ່ມຕົ້ນແລະເຮັດທຸລະກໍາ. ຂໍ້ຍົກເວັ້ນແມ່ນຖ້າ
"--lock" ແມ່ນ 3.
ຖ້າ "--no-transaction" ຖືກລະບຸ, ຫຼັງຈາກນັ້ນ "LOCK TABLES" ຖືກໃຊ້ສໍາລັບມູນຄ່າໃດໆຂອງ
"--lock". ເບິ່ງ "--[ບໍ່]ທຸລະກໍາ".
--lock-and-rename
ລັອກຕາຕະລາງຕົ້ນທາງ ແລະປາຍທາງ, ຊິງຄ໌, ຈາກນັ້ນສະຫຼັບຊື່. ນີ້ແມ່ນເປັນປະໂຫຍດເປັນ
ຕາຕະລາງ ALTER ທີ່ມີການຂັດຂວາງຫນ້ອຍ, ເມື່ອຕາຕະລາງມີຄວາມສົມເຫດສົມຜົນໃນ sync ກັບກັນແລະກັນ
(ເຊິ່ງທ່ານອາດຈະເລືອກທີ່ຈະເຮັດສໍາເລັດດ້ວຍວິທີໃດກໍ່ຕາມ, ລວມທັງການຖິ້ມຂີ້ເຫຍື້ອແລະໂຫຼດໃຫມ່
ຫຼືແມ້ກະທັ້ງບາງສິ່ງບາງຢ່າງເຊັ່ນ: pt-archiver). ມັນຮຽກຮ້ອງໃຫ້ມີສອງ DSNs ແລະສົມມຸດວ່າພວກເຂົາ
ຢູ່ໃນເຄື່ອງແມ່ຂ່າຍດຽວກັນ, ສະນັ້ນມັນບໍ່ລໍຖ້າສໍາລັບການ replication ຫຼືຄ້າຍຄືກັນ. ຕາຕະລາງແມ່ນ
ລັອກດ້ວຍ LOCK TABES.
-ລະຫັດຜ່ານ
ຮູບແບບສັ້ນ: -p; ປະເພດ: string
ລະຫັດຜ່ານທີ່ຈະໃຊ້ໃນເວລາເຊື່ອມຕໍ່. ຖ້າລະຫັດຜ່ານມີເຄື່ອງໝາຍຈຸດ, ພວກມັນຈະຕ້ອງຖືກຫລົບໜີ
ກັບ backslash: "ການສອບເສັງ, ple"
--pid
ປະເພດ: string
ສ້າງໄຟລ໌ PID ທີ່ໃຫ້. ເຄື່ອງມືຈະບໍ່ເລີ່ມຕົ້ນຖ້າໄຟລ໌ PID ມີຢູ່ແລ້ວແລະ
PID ທີ່ມັນມີຢູ່ແຕກຕ່າງຈາກ PID ໃນປັດຈຸບັນ. ຢ່າງໃດກໍຕາມ, ຖ້າໄຟລ໌ PID
ມີຢູ່ ແລະ PID ທີ່ມັນບັນຈຸບໍ່ໄດ້ເຮັດວຽກອີກຕໍ່ໄປ, ເຄື່ອງມືຈະຂຽນທັບ PID
ໄຟລ໌ທີ່ມີ PID ໃນປັດຈຸບັນ. ໄຟລ໌ PID ຈະຖືກລຶບອອກໂດຍອັດຕະໂນມັດເມື່ອເຄື່ອງມືອອກ.
--ພອດ
ຮູບແບບສັ້ນ: -P; ປະເພດ: int
ໝາຍເລກພອດເພື່ອໃຊ້ສຳລັບການເຊື່ອມຕໍ່.
--ພິມ
ພິມຄໍາຖາມທີ່ຈະແກ້ໄຂຄວາມແຕກຕ່າງ.
ຖ້າທ່ານບໍ່ໄວ້ວາງໃຈ "pt-table-sync", ຫຼືພຽງແຕ່ຕ້ອງການເບິ່ງສິ່ງທີ່ມັນຈະເຮັດ, ນີ້ແມ່ນ
ວິທີທີ່ດີທີ່ຈະປອດໄພ. ຄໍາຖາມເຫຼົ່ານີ້ແມ່ນ SQL ທີ່ຖືກຕ້ອງແລະທ່ານສາມາດດໍາເນີນການດ້ວຍຕົນເອງຖ້າທ່ານ
ຕ້ອງການ sync ຕາຕະລາງດ້ວຍຕົນເອງ.
--recursion ວິທີການ
ປະເພດ: array; ຄ່າເລີ່ມຕົ້ນ: processlist, hosts
ວິທີການ recursion ທີ່ຕ້ອງການໃຊ້ເພື່ອຊອກຫາສໍາລອງ.
ວິທີການທີ່ເປັນໄປໄດ້ແມ່ນ:
ວິທີການນໍາໃຊ້
=========== ==================
ລາຍການຂະບວນການສະແດງລາຍການຂະບວນການ
ເຈົ້າພາບສະແດງ SLAVE HOSTS
none ຢ່າຊອກຫາທາດ
ວິທີການບັນຊີລາຍການແມ່ນມັກເພາະວ່າ SHOW SLAVE HOSTS ບໍ່ຫນ້າເຊື່ອຖື.
ຢ່າງໃດກໍ່ຕາມ, ວິທີການໂຮດແມ່ນຕ້ອງການຖ້າເຄື່ອງແມ່ຂ່າຍໃຊ້ພອດທີ່ບໍ່ແມ່ນມາດຕະຖານ (ບໍ່ແມ່ນ
3306). ປົກກະຕິແລ້ວ pt-table-sync ເຮັດສິ່ງທີ່ຖືກຕ້ອງແລະຊອກຫາສໍາລອງ, ແຕ່ທ່ານອາດຈະ
ໃຫ້ວິທີການທີ່ມັກແລະມັນຈະຖືກນໍາໃຊ້ກ່ອນ. ຖ້າຫາກວ່າມັນບໍ່ພົບສໍາລອງໃດໆ, ໄດ້
ວິທີການອື່ນໆຈະຖືກພະຍາຍາມ.
--ປ່ຽນແທນ
ຂຽນຂໍ້ຄວາມ "INSERT" ແລະ "UPDATE" ທັງໝົດເປັນ "REPLACE".
ນີ້ຈະຖືກເປີດໂດຍອັດຕະໂນມັດຕາມຄວາມຕ້ອງການເມື່ອມີການລະເມີດດັດສະນີທີ່ເປັນເອກະລັກ.
--replicate
ປະເພດ: string
ຕາຕະລາງການຊິງຄ໌ທີ່ມີລາຍຊື່ແຕກຕ່າງກັນໃນຕາຕະລາງນີ້.
ລະບຸວ່າ "pt-table-sync" ຄວນກວດເບິ່ງຕາຕະລາງທີ່ລະບຸເພື່ອຊອກຫາຂໍ້ມູນນັ້ນ
ແຕກຕ່າງກັນ. ຕາຕະລາງແມ່ນຄືກັນກັບການໂຕ້ຖຽງຂອງຊື່ດຽວກັນກັບ pt-table-.
checksum. ນັ້ນແມ່ນ, ມັນມີບັນທຶກຂອງຕາຕະລາງ (ແລະຂອບເຂດຂອງຄ່າ) ແຕກຕ່າງກັນ
ລະຫວ່າງນາຍ ແລະຂ້າທາດ.
ສໍາລັບແຕ່ລະຕາຕະລາງແລະຂອບເຂດຂອງຄ່າທີ່ສະແດງໃຫ້ເຫັນຄວາມແຕກຕ່າງລະຫວ່າງແມ່ບົດແລະ
slave, "pt-table-checksum" ຈະ sync ຕາຕະລາງນັ້ນ, ດ້ວຍປະໂຫຍກ "WHERE" ທີ່ເຫມາະສົມ,
ກັບນາຍຂອງຕົນ.
ນີ້ຈະຕັ້ງ "--wait" ໂດຍອັດຕະໂນມັດເປັນ 60 ແລະເຮັດໃຫ້ເກີດການປ່ຽນແປງໃນແມ່ແບບ
ແທນທີ່ຈະເປັນສໍາລອງໄດ້.
ຖ້າ "--sync-to-master" ຖືກລະບຸ, ເຄື່ອງມືຈະສົມມຸດວ່າເຄື່ອງແມ່ຂ່າຍທີ່ທ່ານລະບຸແມ່ນ
ສໍາລອງ, ແລະເຊື່ອມຕໍ່ກັບແມ່ແບບປົກກະຕິເພື່ອ sync.
ຖ້າບໍ່ດັ່ງນັ້ນ, ມັນຈະພະຍາຍາມໃຊ້ "SHOW PROCESSLIST" ເພື່ອຊອກຫາທາດຂອງເຄື່ອງແມ່ຂ່າຍທີ່ທ່ານ
ລະບຸ. ຖ້າມັນບໍ່ສາມາດຊອກຫາສໍາລອງໃດໆໂດຍຜ່ານ "SHOW PROCESSLIST", ມັນຈະກວດສອບ
"ສະແດງເຈົ້າພາບ SLAVE" ແທນ. ທ່ານຕ້ອງປັບຄ່າ "report-host", ຂອງຂ້າໃຊ້ແຕ່ລະຄົນ.
"report-port" ແລະທາງເລືອກອື່ນໆສໍາລັບການນີ້ເຮັດວຽກທີ່ຖືກຕ້ອງ. ຫຼັງຈາກຊອກຫາສໍາລອງ, ມັນຈະ
ກວດເບິ່ງຕາຕະລາງທີ່ລະບຸໄວ້ໃນແຕ່ລະ slave ເພື່ອຊອກຫາຂໍ້ມູນທີ່ຕ້ອງໄດ້ຮັບການ sync, ແລະ
sync ມັນ.
ເຄື່ອງມືກວດສອບການຄັດລອກຕົ້ນສະບັບຂອງຕາຕະລາງທໍາອິດ, ສົມມຸດວ່າແມ່ບົດແມ່ນ
ອາດເປັນທາດເຊັ່ນກັນ. ຕາຕະລາງໃດໆທີ່ສະແດງໃຫ້ເຫັນຄວາມແຕກຕ່າງຢູ່ທີ່ນັ້ນ ບໍ່ be
synced ສຸດສໍາລອງ. ຕົວຢ່າງ, ສົມມຸດວ່າການຈໍາລອງຂອງທ່ານຖືກຕັ້ງເປັນ A->B,
B->C, B->D. ສົມມຸດວ່າທ່ານໃຊ້ການໂຕ້ຖຽງນີ້ແລະລະບຸເຄື່ອງແມ່ຂ່າຍ B. ເຄື່ອງມືຈະ
ກວດສອບການສໍາເນົາຂອງຕາຕະລາງຂອງເຄື່ອງແມ່ຂ່າຍ B. ຖ້າມັນຄ້າຍຄືຂໍ້ມູນຂອງເຄື່ອງແມ່ຂ່າຍ B ໃນຕາຕະລາງ
"test.tbl1" ແມ່ນແຕກຕ່າງຈາກສຳເນົາຂອງເຊີບເວີ A, ເຄື່ອງມືຈະບໍ່ຊິງຄ໌ຕາຕະລາງນັ້ນ
ເຊີບເວີ C ແລະ D.
--set-vars
ປະເພດ: Array
ກໍານົດຕົວແປ MySQL ໃນບັນຊີລາຍຊື່ທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດຂອງຄູ່ "variable=value".
ໂດຍຄ່າເລີ່ມຕົ້ນ, ເຄື່ອງມືກໍານົດ:
wait_timeout=10000
ຕົວແປທີ່ລະບຸໄວ້ໃນເສັ້ນຄໍາສັ່ງ override ຄ່າເລີ່ມຕົ້ນເຫຼົ່ານີ້. ຍົກຕົວຢ່າງ,
ການລະບຸ "--set-vars wait_timeout=500" ລົບລ້າງຄ່າເລີ່ມຕົ້ນຂອງ 10000.
ເຄື່ອງມືພິມຄໍາເຕືອນແລະສືບຕໍ່ຖ້າຫາກວ່າຕົວປ່ຽນແປງບໍ່ສາມາດໄດ້ຮັບການຕັ້ງຄ່າ.
--ຊັອກເກັດ
ຮູບແບບສັ້ນ: -S; ປະເພດ: string
ໄຟລ໌ socket ໃຊ້ສໍາລັບການເຊື່ອມຕໍ່.
--sync-to-master
ປະຕິບັດ DSN ເປັນສໍາລອງແລະ sync ກັບແມ່ຂອງມັນ.
ປະຕິບັດຕໍ່ເຄື່ອງແມ່ຂ່າຍທີ່ທ່ານລະບຸວ່າເປັນສໍາລອງ. ກວດສອບ "ສະແດງສະຖານະ SLAVE", ເຊື່ອມຕໍ່ກັບ
ແມ່ຂອງເຄື່ອງແມ່ຂ່າຍ, ແລະປະຕິບັດກັບແມ່ບົດເປັນແຫຼ່ງແລະສໍາລອງເປັນ
ຈຸດໝາຍປາຍທາງ. ເຮັດໃຫ້ເກີດການປ່ຽນແປງໃນຕົ້ນສະບັບ. ຕັ້ງ "-- ລໍຖ້າ" ເປັນ 60 ໂດຍ
ຄ່າເລີ່ມຕົ້ນ, ຕັ້ງ "--lock" ເປັນ 1 ໂດຍຄ່າເລີ່ມຕົ້ນ, ແລະປິດການໃຊ້ງານ "--[no]transaction" ຕາມຄ່າເລີ່ມຕົ້ນ.
ເບິ່ງ "--replicate", ເຊິ່ງປ່ຽນພຶດຕິກໍາຂອງຕົວເລືອກນີ້.
--ຕາຕະລາງ
ຮູບແບບສັ້ນ: -t; ປະເພດ: hash
ຊິງຄ໌ພຽງແຕ່ລາຍຊື່ຕາຕະລາງທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ.
ຊື່ຕາຕະລາງອາດມີຄຸນສົມບັດກັບຊື່ຖານຂໍ້ມູນ.
--ໝົດເວລາ-ຕົກລົງ
ສືບຕໍ່ໄປຖ້າ "-- ລໍຖ້າ" ລົ້ມເຫລວ.
ຖ້າທ່ານລະບຸ "-- ລໍຖ້າ" ແລະສໍາລອງບໍ່ໄດ້ຂຶ້ນກັບຕໍາແຫນ່ງຂອງນາຍກ່ອນ
ເວລາລໍຖ້າອອກ, ພຶດຕິກໍາເລີ່ມຕົ້ນແມ່ນເພື່ອເອົາລູກອອກ. ທາງເລືອກນີ້ເຮັດໃຫ້ເຄື່ອງມືຮັກສາ
ຕໍ່ໄປ. ການເຕືອນໄພ: ຖ້າທ່ານກໍາລັງພະຍາຍາມທີ່ຈະໄດ້ຮັບການປຽບທຽບທີ່ສອດຄ່ອງລະຫວ່າງ
ສອງເຊີບເວີ, ທ່ານອາດຈະບໍ່ຕ້ອງການທີ່ຈະສືບຕໍ່ຕໍ່ໄປຫຼັງຈາກຫມົດເວລາ.
--[ບໍ່]ທຸລະກຳ
ໃຊ້ທຸລະກໍາແທນທີ່ຈະເປັນ "LOCK TABES".
granularity ຂອງການເລີ່ມຕົ້ນແລະການເຮັດທຸລະກໍາແມ່ນຄວບຄຸມໂດຍ "--lock".
ອັນນີ້ຖືກເປີດໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ, ແຕ່ເນື່ອງຈາກ "--lock" ຖືກປິດໃຊ້ງານໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນບໍ່ມີ
ຜົນກະທົບ.
ຕົວເລືອກສ່ວນໃຫຍ່ທີ່ເປີດໃຊ້ການລັອກຍັງປິດການເຮັດທຸລະກໍາໂດຍຄ່າເລີ່ມຕົ້ນ, ດັ່ງນັ້ນຖ້າທ່ານຕ້ອງການ
ເພື່ອໃຊ້ການລັອກການເຮັດທຸລະກໍາ (ຜ່ານ "LOCK IN SHARE MODE" ແລະ "FOR UPDATE", ທ່ານຕ້ອງ
ລະບຸ "--transaction" ຢ່າງຈະແຈ້ງ.
ຖ້າຫາກວ່າທ່ານບໍ່ໄດ້ລະບຸ "--transaction" ຢ່າງຊັດເຈນ "pt-table-sync" ຈະຕັດສິນໃຈກ່ຽວກັບການຕໍ່.
ພື້ນຖານຕາຕະລາງບໍ່ວ່າຈະໃຊ້ການເຮັດທຸລະກໍາຫຼືການລັອກຕາຕະລາງ. ມັນໃຊ້ໃນປັດຈຸບັນ
ການເຮັດທຸລະກໍາໃນຕາຕະລາງ InnoDB, ແລະການລັອກຕາຕະລາງໃນອື່ນໆທັງຫມົດ.
ຖ້າ "--no-transaction" ຖືກລະບຸ, ຫຼັງຈາກນັ້ນ "pt-table-sync" ຈະບໍ່ໃຊ້ທຸລະກໍາຢູ່ທີ່.
ທັງຫມົດ (ບໍ່ແມ່ນແຕ່ສໍາລັບຕາຕະລາງ InnoDB) ແລະການລັອກແມ່ນຄວບຄຸມໂດຍ "--lock".
ເມື່ອເປີດໃຊ້ງານ, ຢ່າງຊັດເຈນ ຫຼື implicitly, ລະດັບການໂດດດ່ຽວການເຮັດທຸລະກໍາແມ່ນຖືກກໍານົດ
"ອ່ານຊໍ້າຄືນໄດ້" ແລະການເຮັດທຸລະກໍາແມ່ນເລີ່ມຕົ້ນ "ດ້ວຍພາບຖ່າຍທີ່ສອດຄ່ອງ".
--ຕັດ
ຖັນ "TRIM()" "VARCHAR" ໃນໂໝດ "BIT_XOR" ແລະ "ACCUM". ຊ່ວຍເມື່ອປຽບທຽບ MySQL
4.1 ຫາ >= 5.0.
ນີ້ແມ່ນເປັນປະໂຫຍດໃນເວລາທີ່ທ່ານບໍ່ສົນໃຈກັບຄວາມແຕກຕ່າງຂອງພື້ນທີ່ຕໍ່ຫນ້າລະຫວ່າງ MySQL
ລຸ້ນຕ່າງໆແຕກຕ່າງກັນໃນການຈັດການພື້ນທີ່ຕໍ່ທ້າຍ. MySQL 5.0 ແລະຕໍ່ມາທັງຫມົດ
ຮັກສາຊ່ອງຫວ່າງໃນ "VARCHAR", ໃນຂະນະທີ່ສະບັບກ່ອນຫນ້າຈະເອົາພວກມັນອອກ.
--[ບໍ່]unique-checks
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ເປີດໃຊ້ການກວດສອບລະຫັດທີ່ບໍ່ຊໍ້າກັນ ("SET UNIQUE_CHECKS=1").
ການລະບຸ "--no-unique-checks" ຈະ "SET UNIQUE_CHECKS=0".
-ຜູ້ໃຊ້
ຮູບແບບສັ້ນ: -u; ປະເພດ: string
ຜູ້ໃຊ້ສໍາລັບການເຂົ້າສູ່ລະບົບຖ້າບໍ່ແມ່ນຜູ້ໃຊ້ປະຈຸບັນ.
-- verbose
ຮູບແບບສັ້ນ: -v; ສະສົມ: ແມ່ນ
ພິມຜົນໄດ້ຮັບຂອງການດໍາເນີນງານ sync.
ເບິ່ງ "OUTPUT" ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມກ່ຽວກັບຜົນຜະລິດ.
- ການປ່ຽນແປງ
ສະແດງສະບັບແລະອອກ.
--[ບໍ່ມີການກວດສອບສະບັບ
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ກວດເບິ່ງເວີຊັນຫຼ້າສຸດຂອງ Percona Toolkit, MySQL, ແລະໂຄງການອື່ນໆ.
ນີ້ແມ່ນມາດຕະຖານ "ກວດສອບການປັບປຸງອັດຕະໂນມັດ" ຄຸນນະສົມບັດ, ມີສອງເພີ່ມເຕີມ
ຄຸນລັກສະນະ. ຫນ້າທໍາອິດ, ເຄື່ອງມືກວດສອບສະບັບຂອງບັນດາໂຄງການອື່ນໆໃນລະບົບທ້ອງຖິ່ນໃນ
ນອກຈາກສະບັບຂອງຕົນເອງ. ຕົວຢ່າງ, ມັນກວດເບິ່ງເວີຊັນຂອງທຸກເຄື່ອງແມ່ຂ່າຍ MySQL
ມັນເຊື່ອມຕໍ່ກັບ, Perl, ແລະໂມດູນ Perl DBD::mysql. ອັນທີສອງ, ມັນກວດເບິ່ງແລະເຕືອນ
ກ່ຽວກັບສະບັບທີ່ມີບັນຫາທີ່ຮູ້ຈັກ. ຕົວຢ່າງ, MySQL 5.5.25 ມີ bug ທີ່ສໍາຄັນແລະ
ໄດ້ຖືກປ່ອຍອອກມາເມື່ອ 5.5.25a.
ການອັບເດດ ຫຼືບັນຫາທີ່ຮູ້ຈັກຈະຖືກພິມໃສ່ STDOUT ກ່ອນທີ່ເຄື່ອງມືຈະອອກມາປົກກະຕິ.
ຄຸນສົມບັດນີ້ບໍ່ຄວນລົບກວນການເຮັດວຽກປົກກະຕິຂອງເຄື່ອງມື.
ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ, ໄປຢ້ຽມຢາມ .
--ລໍຖ້າ
ຮູບແບບສັ້ນ: -w; ປະເພດ: ເວລາ
ດົນປານໃດທີ່ຈະລໍຖ້າສໍາລັບຂ້າໃຊ້ເພື່ອຈັບເຖິງນາຍຂອງເຂົາເຈົ້າ.
ເຮັດໃຫ້ນາຍລໍຖ້າສໍາລັບສໍາລັບຈັບເຖິງໃນການຈໍາລອງກ່ອນທີ່ຈະສົມທຽບ
ໂຕະ. ຄ່າແມ່ນຈໍານວນວິນາທີທີ່ຈະລໍຖ້າກ່ອນທີ່ຈະຫມົດເວລາ (ເບິ່ງ
"--ໝົດເວລາ-ຕົກລົງ"). ຕັ້ງ "--lock" ເປັນ 1 ແລະ "--[no]ທຸລະກໍາ" ເປັນ 0 ຕາມຄ່າເລີ່ມຕົ້ນ. ຖ້າເຈົ້າ
ເບິ່ງຂໍ້ຜິດພາດດັ່ງຕໍ່ໄປນີ້,
MASTER_POS_WAIT ກັບຄືນ -1
ມັນຫມາຍຄວາມວ່າຫມົດເວລາເກີນແລະທ່ານຈໍາເປັນຕ້ອງເພີ່ມມັນ.
ຄ່າເລີ່ມຕົ້ນຂອງຕົວເລືອກນີ້ແມ່ນມີອິດທິພົນຈາກທາງເລືອກອື່ນ. ເພື່ອເບິ່ງວ່າມູນຄ່າແມ່ນຫຍັງ
ໃນຜົນກະທົບ, ດໍາເນີນການດ້ວຍ "--help".
ເພື່ອປິດການລໍຖ້າທັງຫມົດ (ຍົກເວັ້ນການລັອກ), ໃຫ້ລະບຸ "--wait" 0. ນີ້ຈະຊ່ວຍໃຫ້ເວລາ
ສໍາລອງແມ່ນ lagging ໃນຕາຕະລາງທີ່ບໍ່ໄດ້ຖືກ synced.
-- ບ່ອນໃດ
ປະເພດ: string
ຂໍ້ "ບ່ອນໃດ" ເພື່ອຈໍາກັດການຊິງຄ໌ກັບສ່ວນຫນຶ່ງຂອງຕາຕະລາງ.
--[ບໍ່]ສູນ-chunk
ຄ່າເລີ່ມຕົ້ນ: ແມ່ນແລ້ວ
ເພີ່ມຊຸດສຳລັບແຖວທີ່ມີຄ່າສູນ ຫຼືສູນທຽບເທົ່າ. ພຽງແຕ່ມີຜົນກະທົບໃນເວລາທີ່
"--chunk-size" ຖືກລະບຸ. ຈຸດປະສົງຂອງ chunk ສູນແມ່ນເພື່ອເກັບກໍາ a
ມີທ່າແຮງຫຼາຍຂອງຄ່າສູນທີ່ຈະບໍ່ສົມດຸນກັບຂະໜາດຂອງຄ່າທຳອິດ
ກ້ອນ. ຕົວຢ່າງ, ຖ້າຕົວເລກລົບຫຼາຍຖືກໃສ່ເຂົ້າໄປໃນ unsigned
ຖັນຈຳນວນເຕັມທີ່ເຮັດໃຫ້ມັນຖືກເກັບໄວ້ເປັນສູນ, ຈາກນັ້ນຄ່າສູນເຫຼົ່ານີ້ຈະຖືກຈັບ
ໂດຍສູນ chunk ແທນທີ່ຈະເປັນ chunk ທໍາອິດແລະທຸກຄ່າທີ່ບໍ່ແມ່ນສູນຂອງມັນ.
DSN OPTIONS
ຕົວເລືອກ DSN ເຫຼົ່ານີ້ຖືກໃຊ້ເພື່ອສ້າງ DSN. ແຕ່ລະທາງເລືອກແມ່ນໃຫ້ຄື "option=value".
ຕົວເລືອກແມ່ນຕົວພິມນ້ອຍ, ດັ່ງນັ້ນ P ແລະ p ບໍ່ແມ່ນທາງເລືອກດຽວກັນ. ບໍ່ສາມາດມີ
ຊ່ອງຫວ່າງກ່ອນ ຫຼືຫຼັງ "=" ແລະຖ້າຄ່າມີຊ່ອງຫວ່າງມັນຈະຕ້ອງຖືກອ້າງອີງ.
ຕົວເລືອກ DSN ແມ່ນຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ. ເບິ່ງ manpage percona-toolkit ສໍາລັບລາຍລະອຽດເຕັມ.
ກ
dsn: charset; ສຳເນົາ: ແມ່ນແລ້ວ
ຕັ້ງຕົວອັກສອນເລີ່ມຕົ້ນ.
·ດ
dsn: ຖານຂໍ້ມູນ; ສຳເນົາ: ແມ່ນແລ້ວ
ຖານຂໍ້ມູນທີ່ມີຕາຕະລາງທີ່ຈະ synced.
· F
dsn: mysql_read_default_file; ສຳເນົາ: ແມ່ນແລ້ວ
ອ່ານພຽງແຕ່ຕົວເລືອກເລີ່ມຕົ້ນຈາກໄຟລ໌ທີ່ໃຫ້
h
dsn: ເຈົ້າພາບ; ສຳເນົາ: ແມ່ນແລ້ວ
ເຊື່ອມຕໍ່ຫາເຈົ້າພາບ.
· ປ
dsn: ລະຫັດຜ່ານ; ສຳເນົາ: ແມ່ນແລ້ວ
ລະຫັດຜ່ານທີ່ຈະໃຊ້ໃນເວລາເຊື່ອມຕໍ່. ຖ້າລະຫັດຜ່ານມີເຄື່ອງໝາຍຈຸດ, ພວກມັນຈະຕ້ອງຖືກຫລົບໜີ
ກັບ backslash: "ການສອບເສັງ, ple"
·ປ
dsn: ພອດ; ສຳເນົາ: ແມ່ນແລ້ວ
ໝາຍເລກພອດເພື່ອໃຊ້ສຳລັບການເຊື່ອມຕໍ່.
·ສ
dsn: mysql_socket; ສຳເນົາ: ແມ່ນແລ້ວ
ໄຟລ໌ socket ໃຊ້ສໍາລັບການເຊື່ອມຕໍ່.
· ທ
ສຳເນົາ: ແມ່ນແລ້ວ
ຕາຕະລາງທີ່ຈະ synced.
· ເຈົ້າ
dsn: ຜູ້ໃຊ້; ສຳເນົາ: ແມ່ນແລ້ວ
ຜູ້ໃຊ້ສໍາລັບການເຂົ້າສູ່ລະບົບຖ້າບໍ່ແມ່ນຜູ້ໃຊ້ປະຈຸບັນ.
ENVIRONMENT
ຕົວແປສະພາບແວດລ້ອມ "PTDEBUG" ເປີດໃຊ້ຜົນການແກ້ບັນຫາ verbose ໄປຫາ STDERR. ເພື່ອເປີດໃຊ້ງານ
debugging ແລະເກັບກໍາຜົນຜະລິດທັງຫມົດໄປຍັງໄຟລ໌, ດໍາເນີນການເຄື່ອງມືເຊັ່ນ:
PTDEBUG=1 pt-table-sync ... > FILE 2 >&1
ຈົ່ງລະວັງ: ການດີບັ໊ກຜົນອອກແມ່ນ voluminous ແລະສາມາດສ້າງຜົນຜະລິດຫຼາຍ megabytes.
SYSTEM ສິ່ງທີ່ຕ້ອງມີ
ທ່ານຕ້ອງການ Perl, DBI, DBD::mysql, ແລະບາງແພັກເກັດຫຼັກທີ່ຄວນຈະຖືກຕິດຕັ້ງຢູ່ໃນໃດກໍ່ຕາມ.
ສະບັບໃຫມ່ທີ່ສົມເຫດສົມຜົນຂອງ Perl.
ໃຊ້ pt-table-syncp ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
