pg_comparator - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

pg_comparator - ການປຽບທຽບເນື້ອໃນຕາຕະລາງທີ່ມີປະສິດທິພາບແລະ synchronization

ສະຫຼຸບສັງລວມ

pg_comparator [ຕົວເລືອກເປັນ - ຊ່ວຍ -- ທາງ​ເລືອກ​ --ຜູ້ຊາຍ]conn1 conn2

ລາຍລະອຽດ

script ນີ້ປະຕິບັດການປຽບທຽບເຄືອຂ່າຍແລະເວລາທີ່ມີປະສິດທິພາບຫຼື synchronization ຂອງສອງ
ອາດຈະເປັນຕາຕະລາງຂະຫນາດໃຫຍ່ໃນ PostgreSQL, MySQL or SQLite ຖານ​ຂໍ້​ມູນ​, ດັ່ງ​ນັ້ນ​ທີ່​ຈະ​ກວດ​ສອບ​ການ​ແຊກ​,
ອັບເດດ ຫຼືລຶບ tuples ລະຫວ່າງຕາຕະລາງເຫຼົ່ານີ້. ສູດການຄິດໄລ່ແມ່ນມີປະສິດທິພາບໂດຍສະເພາະຖ້າ
ຄວາມແຕກຕ່າງທີ່ຄາດໄວ້ແມ່ນຂ້ອນຂ້າງນ້ອຍ.

ການປະຕິບັດແມ່ນຂ້ອນຂ້າງທົ່ວໄປ: ປຸ່ມຫຼາຍຖັນ (ແຕ່ຕ້ອງມີລະຫັດ!), ບໍ່ມີ
ສົມມຸດຕິຖານຂອງປະເພດຂໍ້ມູນອື່ນໆທີ່ພວກເຂົາສາມາດຖືກໂຍນໃສ່ຂໍ້ຄວາມ, ຊຸດຍ່ອຍຂອງຖັນສາມາດເປັນ
ໃຊ້ສໍາລັບການປຽບທຽບ, ການຈັດການຄ່າ NULL...

ສະຄຣິບນີ້ເນັ້ນໃສ່ຂັ້ນຕອນການປຽບທຽບ, ດັ່ງນັ້ນທາງເລືອກຫຼາຍ. ຄວາມຈິງທີ່ວ່າມັນ
ອາດຈະເຮັດຫຍັງທີ່ເປັນປະໂຫຍດ, ເຊັ່ນ: ການກວດສອບວ່າເຄື່ອງມື replication ແທ້ຈິງ replicates
ຂໍ້ມູນຂອງທ່ານ, ຫຼືເຊັ່ນຕາຕະລາງ synchronizing, ເປັນພຽງແຕ່ຜົນຂ້າງຄຽງ.

OPTIONS

ຕົວເລືອກອະນຸຍາດໃຫ້ຮ້ອງຂໍການຊ່ວຍເຫຼືອຫຼືປັບຕົວກໍານົດການພາຍໃນບາງຢ່າງ. ໂຕໜັງສືສັ້ນ
ທາງເລືອກແມ່ນຍັງມີຢູ່, ໂດຍປົກກະຕິແລ້ວມີຕົວອັກສອນທໍາອິດຂອງຊື່ທາງເລືອກ.

"--aggregate=(sum|xor)" ຫຼື "-a (sum|xor)"
ຟັງຊັນການລວບລວມທີ່ຈະໃຊ້ສໍາລັບການສະຫຼຸບ, ບໍ່ວ່າຈະ xor or sum. ມັນຕ້ອງດໍາເນີນການກ່ຽວກັບ
ຜົນຂອງການທໍາງານຂອງ checksum. ສໍາລັບ PostgreSQL ແລະ SQLite, ໄດ້ xor ລວມ
ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້​ຮັບ​ການ​ໂຫຼດ​. ມີບັນຫາການເຊັນ / ບໍ່ໄດ້ເຊັນຢູ່ໃນ hash ທີ່ສໍາຄັນໃນເວລາທີ່ການນໍາໃຊ້ xor
ສໍາລັບການປຽບທຽບຕາຕະລາງໃນ MySQL ຫຼື SQLite vs PostgreSQL. ພວກເຮົາສະຫນອງ "ISUM" ໃຫມ່.
ລວມສໍາລັບ SQLite ເພາະວ່າທັງ "SUM" ແລະ "TOTAL" ເຮັດການຈັດການທີ່ບໍ່ເຂົ້າກັນໄດ້
ເຕັມຈຳນວນເຕັມ.

ເລີ່ມຕົ້ນແມ່ນ sum ເນື່ອງຈາກວ່າມັນສາມາດໃຊ້ໄດ້ໂດຍຄ່າເລີ່ມຕົ້ນແລະເຮັດວຽກໃນຮູບແບບປະສົມ.

"-- ຖາມຜ່ານ"
ຂໍລະຫັດຜ່ານແບບໂຕ້ຕອບ. ເບິ່ງຕົວເລືອກ "--env-pass" ຂ້າງລຸ່ມນີ້.

ຄ່າເລີ່ມຕົ້ນບໍ່ແມ່ນການຮ້ອງຂໍໃຫ້ມີລະຫັດຜ່ານ.

"-- asynchronous" ຫຼື "-A", "--no-asynchronous" ຫຼື "-X"
ວ່າຈະດໍາເນີນການສອບຖາມແບບບໍ່ຊິ້ງ. ນີ້ສະຫນອງການຂະຫນານບາງ, ຢ່າງໃດກໍຕາມທັງສອງ
ການເຊື່ອມຕໍ່ແມ່ນ synchronized ຫຼາຍຫຼືຫນ້ອຍຕໍ່ການສອບຖາມ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການໃຊ້ແບບສອບຖາມແບບບໍ່ຊິ້ງໂຄນເພື່ອເປີດໃຊ້ການຂະໜານບາງອັນ.

"--checksum-computation=(ສ້າງ|ໃສ່)" ຫຼື "--cc=..."
ວິທີການສ້າງຕາຕະລາງ checksum. ໃຊ້ ສ້າງ ເພື່ອໃຊ້ "CREATE ... AS SELECT ... "
ສອບຖາມ, ຫຼື ໃສ່ ເພື່ອໃຊ້ "CREATE ...; INSERT ... SELECT ... ". ອະດີດຈະ
ຮຽກຮ້ອງໃຫ້ມີການນັບເພີ່ມເຕີມເພື່ອໃຫ້ໄດ້ຂະຫນາດຕາຕະລາງ, ດັ່ງນັ້ນໃນທີ່ສຸດມີສອງ
ແນວໃດກໍ່ຕາມ. ມີບັນຫາກ່ຽວກັບຂະຫນາດຂອງປະເພດ ໃສ່ ຍຸດທະສາດກ່ຽວກັບ MySQL, ໄດ້
ຄວາມຍາວສະຕຣິງຫຼັກທີ່ສະສົມຈະຕ້ອງມີໜ້ອຍກວ່າ 64 ໄບຕ໌.

ເລີ່ມຕົ້ນແມ່ນ ສ້າງ ເນື່ອງຈາກວ່າມັນສະເຫມີເຮັດວຽກສໍາລັບທັງສອງຖານຂໍ້ມູນ.

"--checksum-function=fun" ຫຼື "--cf=fun" ຫຼື "-c ມ່ວນ"
ຟັງຊັນ Checksum ທີ່ຈະໃຊ້, ບໍ່ວ່າຈະ ck, fnv or md5. ສໍາລັບ PostgreSQL, MySQL ແລະ SQLite ໄດ້
ສະຫນອງໃຫ້ ck ແລະ fnv ຟັງຊັນ checksum ຕ້ອງໄດ້ຮັບການໂຫລດເຂົ້າໄປໃນຖານຂໍ້ມູນເປົ້າຫມາຍ.
ເລືອກ md5 ບໍ່ໄດ້ມາຟຣີທັງສອງ: ຟັງຊັນການສົ່ງສັນຍານທີ່ສະຫນອງໃຫ້ຈະຕ້ອງຖືກໂຫລດ
ເຂົ້າໄປໃນຖານຂໍ້ມູນເປົ້າຫມາຍແລະການຄິດໄລ່ແມ່ນລາຄາແພງກວ່າ.

ເລີ່ມຕົ້ນແມ່ນ ck, ຊຶ່ງເປັນໄວ, ໂດຍສະເພາະຖ້າຫາກວ່າການດໍາເນີນງານແມ່ນ cpu-bound ແລະ
ແບນວິດແມ່ນສູງສົມເຫດສົມຜົນ.

"--checksum-size=n" ຫຼື "--check-size=n" ຫຼື "--cs=n" ຫຼື "-zn"
Tuple checksum ຂະຫນາດ, ຕ້ອງເປັນ 2, 4 or 8 ໄບຕ໌. ຂະຫນາດ checksum ທີ່ສໍາຄັນແມ່ນສະເຫມີ 4 bytes
ຍາວ.

ເລີ່ມຕົ້ນແມ່ນ 8, ດັ່ງນັ້ນຄວາມເປັນໄປໄດ້ທາງລົບທີ່ບໍ່ຖືກຕ້ອງແມ່ນຕໍ່າຫຼາຍ. ບໍ່ຄວນມີ
ເຫດຜົນໃນການປ່ຽນແປງນັ້ນ.

"-- ການ​ທໍາ​ຄວາມ​ສະ​ອາດ​"
ວາງ checksum ແລະຕາຕະລາງສະຫຼຸບກ່ອນ. ມີປະໂຫຍດຫຼັງຈາກແລ່ນດ້ວຍ "--no-temp" ແລະ
"--no-clear", ໂດຍປົກກະຕິແລ້ວໃຊ້ສໍາລັບການດີບັກ.

ຄ່າເລີ່ມຕົ້ນບໍ່ແມ່ນການລຸດລົງເພາະວ່າມັນບໍ່ຈໍາເປັນ.

"-- ຈະແຈ້ງ"
ວາງ checksum ແລະຕາຕະລາງສະຫຼຸບຢ່າງຈະແຈ້ງຫຼັງຈາກຄໍານວນ. ໃຫ້ສັງເກດວ່າພວກເຂົາແມ່ນ
ຫຼຸດລົງ implicitly ໂດຍຄ່າເລີ່ມຕົ້ນໃນເວລາທີ່ການເຊື່ອມຕໍ່ຖືກປິດຍ້ອນວ່າເຂົາເຈົ້າຊົ່ວຄາວ, ເບິ່ງ
"-(-ບໍ່)-ຊົ່ວຄາວ" ທາງເລືອກ. ທາງເລືອກນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການ debugging.

ເລີ່ມຕົ້ນແມ່ນ ບໍ່ ເພື່ອລຶບລ້າງຕາຕະລາງ checksum ແລະສະຫຼຸບຢ່າງຈະແຈ້ງ, ເພາະວ່າມັນບໍ່ແມ່ນ
ຕ້ອງການ.

"--debug" ຫຼື "-d"
ຕັ້ງໂໝດດີບັກ. ເຮັດຊ້ຳເພື່ອລະດັບດີບັກທີ່ສູງຂຶ້ນ. ເບິ່ງ "--verbose". ຈົ່ງລະວັງ
ບາງ gards ທີ່ປອດໄພກ່ຽວກັບການຕັ້ງຄ່າທາງເລືອກແມ່ນຂ້າມພາຍໃຕ້ການດີບັກເພື່ອອະນຸຍາດໃຫ້ທົດສອບ
ພາຍ​ໃຕ້​ເງື່ອນ​ໄຂ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​.

ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ໃຫ້ແລ່ນຢູ່ໃນໂໝດດີບັກ.

"--env-pass='var'"
ເອົາລະຫັດຜ່ານຈາກຕົວແປສະພາບແວດລ້ອມ "var1", "var2" ຫຼື "var" ສໍາລັບການເຊື່ອມຕໍ່ຫນຶ່ງ,
ສອງ, ຫຼືທັງສອງ. ນີ້ແມ່ນພະຍາຍາມກ່ອນທີ່ຈະຖາມແບບໂຕ້ຕອບຖ້າ "--ask-pass" ຖືກຕັ້ງໄວ້.

ຄ່າເລີ່ມຕົ້ນບໍ່ແມ່ນການຊອກຫາລະຫັດຜ່ານຈາກຕົວແປສະພາບແວດລ້ອມ.

"--expect n" ຫຼື "-en"
ຈໍາ​ນວນ​ທັງ​ຫມົດ​ຂອງ​ຄວາມ​ແຕກ​ຕ່າງ​ທີ່​ຄາດ​ວ່າ​ຈະ (ການ​ປັບ​ປຸງ​, ການ​ລົບ​ແລະ​ການ​ແຊກ​)​. ທາງເລືອກນີ້ແມ່ນ
ໃຊ້ພຽງແຕ່ສໍາລັບການທົດສອບທີ່ບໍ່ແມ່ນ regression. ເບິ່ງພາກ TESTS.

"--folding-factor=7" ຫຼື "-f 7"
ປັດໄຈພັບ: log2 ຂອງຈໍານວນແຖວທີ່ຈັດກຸ່ມເຂົ້າກັນໃນແຕ່ລະຂັ້ນຕອນ, ເລີ່ມ
ຈາກໃບເພື່ອໃຫ້ຮອບທໍາອິດສະເຫມີຈັດກຸ່ມບັນທຶກຫຼາຍເທົ່າທີ່ເປັນໄປໄດ້. ໄດ້
ພະລັງງານຂອງສອງອະນຸຍາດໃຫ້ຫນຶ່ງໃຊ້ການຄິດໄລ່ຫນ້າກາກ. ຄ່າຕໍ່າສຸດຂອງ 1 ສ້າງ a
ຕົ້ນໄມ້ຖານສອງ.

Default folding factor log2 ແມ່ນ 7, ie ຂະຫນາດ 128 ເທົ່າ. ຄ່າເລີ່ມຕົ້ນນີ້ຖືກເລືອກ
ຫຼັງຈາກການທົດສອບພື້ນຖານບາງຢ່າງກ່ຽວກັບກໍລະນີຂະຫນາດກາງທີ່ມີແບນວິດຂະຫນາດກາງຫຼືຕ່ໍາ. ຄຸນຄ່າຈາກ
4 ຫາ 8 ຄວນເປັນທາງເລືອກທີ່ສົມເຫດສົມຜົນສໍາລັບການຕັ້ງຄ່າສ່ວນໃຫຍ່.

"--help" ຫຼື "-h"
ສະແດງການຊ່ວຍເຫຼືອສັ້ນໆ.

"--key-checksum='kcs'" ຫຼື "--kcs=..."
ໃຊ້ຄຸນລັກສະນະ checksum ຫຼັກຂອງຊື່ນີ້, ເຊິ່ງຕ້ອງມີຢູ່ໃນຕາຕະລາງແລ້ວ
ເພື່ອປຽບທຽບ. ທາງເລືອກນີ້ຍັງຕ້ອງການທາງເລືອກ "--tuple-checksum". ເບິ່ງຍັງ
ພາກສ່ວນຕົວຢ່າງລຸ່ມນີ້ສໍາລັບວິທີຕັ້ງຄ່າ checksum trigger. ພິຈາລະນາ "--use-key"
ແທນທີ່ຖ້າທ່ານມີກະແຈຫຼັກຈຳນວນເຕັມທີ່ແຈກຢາຍຢ່າງສົມເຫດສົມຜົນແລ້ວ.

ຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອສ້າງທັງ checksums ທີ່ສໍາຄັນແລະ tuple ທັນທີ.

"--lock", "--no-lock"
ວ່າຈະລັອກຕາຕະລາງຫຼືບໍ່. ການ​ຕັ້ງ​ຄ່າ​ທາງ​ເລືອກ​ຢ່າງ​ຊັດ​ເຈນ overrides ຄ່າ​ເລີ່ມ​ຕົ້ນ​ທາງ​ດຽວ​
ຫຼືອື່ນ. ສໍາລັບ PostgreSQL, ທາງເລືອກນີ້ຕ້ອງການ "--transaction", ເຊິ່ງຖືກເປີດໃຊ້ໂດຍ
Default

ຄ່າເລີ່ມຕົ້ນແມ່ນຂຶ້ນກັບການປະຕິບັດໃນປະຈຸບັນ: ຕາຕະລາງແມ່ນ ບໍ່ ລັອກ ສໍາ​ລັບ​ການ​ປຽບ​ທຽບ​,
ແຕ່ວ່າມັນແມ່ນ ລັອກ ສໍາລັບການ synchronization.

"--long-read-len=0" ຫຼື "-L 0"
ກໍານົດຂະຫນາດສູງສຸດສໍາລັບການດຶງເອົາວັດຖຸຂະຫນາດໃຫຍ່ຖານສອງ. ດີ, ມັນເບິ່ງຄືວ່າຖືກລະເລີຍຢ່າງຫນ້ອຍ
ໂດຍໄດເວີ PostgreSQL.

ຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອຮັກສາຄ່າເລີ່ມຕົ້ນທີ່ໄດເວີກໍານົດໄວ້.

"--ຜູ້ຊາຍ" ຫຼື "-m"
ສະແດງໜ້າຄູ່ມືແບບໂຕ້ຕອບຢູ່ໃນ terminal.

"--max-ratio=0.1"
ຄວາມພະຍາຍາມຄົ້ນຫາພີ່ນ້ອງສູງສຸດ. ການຄົ້ນຫາຖືກຢຸດຖ້າຈໍານວນຜົນໄດ້ຮັບ
ເກີນຂອບເຂດນີ້ສະແດງອອກຂ້ອນຂ້າງກັບຂະຫນາດຕາຕະລາງ. ໃຊ້ 2.0 ໂດຍບໍ່ຈໍາກັດ
( tuples ທັງຫມົດໄດ້ຖືກລຶບແລະອັນໃຫມ່ໄດ້ຖືກໃສ່).

ເລີ່ມຕົ້ນແມ່ນ 0.1, ie ຄວາມແຕກຕ່າງ 10% ໂດຍລວມແມ່ນອະນຸຍາດໃຫ້ກ່ອນທີ່ຈະໃຫ້ເຖິງ.

"--max-report=n"
ຄວາມພະຍາຍາມຄົ້ນຫາຢ່າງແທ້ຈິງສູງສຸດ. ການຄົ້ນຫາຖືກຢຸດຖ້າຈໍານວນຄວາມແຕກຕ່າງ
ໄປເກີນຂອບເຂດນີ້. ຖ້າຕັ້ງ, ຕົວເລືອກ "--max-ratio" ທີ່ຜ່ານມາຈະຖືກລະເລີຍ,
ຖ້າບໍ່ດັ່ງນັ້ນ, ຄວາມພະຍາຍາມຖືກຄິດໄລ່ດ້ວຍອັດຕາສ່ວນເມື່ອຂະຫນາດຕາຕະລາງຖືກຮູ້ຈັກ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການຄິດໄລ່ຈໍານວນສູງສຸດຂອງຄວາມແຕກຕ່າງທີ່ລາຍງານໂດຍອີງໃສ່
"--max-ratio", ທາງເລືອກ, ສູງສຸດ 100 ຄວາມແຕກຕ່າງທີ່ອະນຸຍາດໃຫ້.

"--max-levels=0"
ຈໍາ​ນວນ​ສູງ​ສຸດ​ຂອງ​ລະ​ດັບ​ການ​ນໍາ​ໃຊ້​. ອະນຸຍາດໃຫ້ຫນຶ່ງເພື່ອຕັດ folding. 0 ຫມາຍຄວາມວ່າບໍ່ມີການຕັດອອກ.
ການຕັ້ງຄ່າ 1 ຈະໃຊ້ພຽງແຕ່ຕາຕະລາງ checksum, ໂດຍບໍ່ມີການສະຫຼຸບ. ມູນຄ່າຂອງ
3 ຫຼື 4 ຈະສົມເຫດສົມຜົນ, ຍ້ອນວ່າລະດັບສຸດທ້າຍຂອງຕົ້ນໄມ້ແມ່ນງາມສໍາລັບ
ສູດຄວາມຊັບຊ້ອນທາງທິດສະດີ, ແຕ່ບໍ່ປັບປຸງການປະຕິບັດໃນການປະຕິບັດ.

ເລີ່ມຕົ້ນແມ່ນ 0.

"--null='ຂໍ້ຄວາມ'"
ວິທີການຈັດການກັບຄ່າ NULL. ບໍ່ວ່າຈະ hash ເພື່ອ hash ຄ່າທັງຫມົດ, ບ່ອນທີ່ NULL ມີຫນຶ່ງພິເສດ
ຄ່າ hash, ຫຼື ຂໍ້ຄວາມ ບ່ອນທີ່ຄ່າ NULL ຖືກແທນທີ່ດ້ວຍສະຕຣິງ "NULL".

ເລີ່ມຕົ້ນແມ່ນ ຂໍ້ຄວາມ ເນື່ອງຈາກວ່າມັນໄວ.

"--ທາງເລືອກ" ຫຼື "-o"
ສະແດງສະຫຼຸບທາງເລືອກ.

"--pg-copy=128"
ທາງ​ເລືອກ​ໃນ​ການ​ທົດ​ລອງ​ການ​ນໍາ​ໃຊ້​ສໍາ​ເນົາ PostgreSQL ແທນ​ທີ່​ຈະ INSERT/UPDATE ໃນ​ເວ​ລາ​ທີ່
synchronizing, ໂດຍ chunks ຂອງຂະຫນາດທີ່ກໍານົດໄວ້.

"--prefix='pgc_cmp'"
ຄໍານໍາຫນ້າຊື່, ອາດຈະເປັນ schema ມີຄຸນສົມບັດ, ໃຊ້ສໍາລັບຕາຕະລາງການປຽບທຽບທີ່ສ້າງຂຶ້ນໂດຍ
ຕົວເລກຕໍ່ທ້າຍກັບມັນ. ພິຈາລະນາປ່ຽນຄໍານໍາຫນ້າຖ້າທ່ານຄາດຫວັງວ່າຫຼາຍໆຄັ້ງ
ການປຽບທຽບເພື່ອດໍາເນີນການພ້ອມກັນກັບຖານຂໍ້ມູນດຽວກັນ.

ຄ່າເລີ່ມຕົ້ນແມ່ນ "pgc_cmp". ຕາຕະລາງ Cheksum ມີຊື່ວ່າ "pgc_cmp_1_0" ແລະ "pgc_cmp_2_0", ແລະ
ຕາຕະລາງສະຫຼຸບແມ່ນຕັ້ງຊື່ໂດຍການເພີ່ມຕົວເລກສຸດທ້າຍ.

"--report", "--no-report"
ລາຍງານລະຫັດທີ່ແຕກຕ່າງກັນຕໍ່ກັບ stdout ຍ້ອນວ່າພວກເຂົາຖືກພົບເຫັນ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການລາຍງານ.

"--separator='|'" ຫຼື "-s '|'"
ສະຕຣິງຕົວແຍກ ຫຼືຕົວໜັງສືທີ່ໃຊ້ໃນການປະກອບຄໍລຳຫຼັກສຳລັບການຄຳນວນ
ເຊັກsums.

ຄ່າເລີ່ມຕົ້ນຂອງທໍ່ '|' ລັກສະນະ.

"--size=n"
ສົມມຸດມູນຄ່ານີ້ເປັນຂະຫນາດຕາຕະລາງ. ມັນພຽງພໍສໍາລັບ algorithm ເພື່ອປະຕິບັດ
ດີວ່າຂະຫນາດນີ້ແມ່ນຢູ່ໃນລໍາດັບຂອງຂະຫນາດຂອງຂະຫນາດຕາຕະລາງຕົວຈິງ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການສອບຖາມຂະຫນາດຕາຕະລາງ, ເຊິ່ງຖືກຂ້າມຖ້າຕົວເລືອກນີ້ຖືກຕັ້ງ.

"--source-1='DBI:...'", "--source-2='...'" ຫຼື "-1 '...'", "-2 '...'"
ເອົາການຄວບຄຸມຢ່າງເຕັມທີ່ຂອງຂໍ້ມູນສະເພາະຂອງແຫຼ່ງ DBI ແລະສ່ວນຫຼາຍແມ່ນຈະບໍ່ສົນໃຈການປຽບທຽບ
ສ່ວນການພິສູດຢືນຢັນຂອງແຫຼ່ງ ຫຼື URL ເປົ້າໝາຍ. ຫນຶ່ງສາມາດເຊື່ອມຕໍ່ກັບ
"DBI:Pg:service=backup", ໃຊ້ໄດເວີສະຫຼັບ, ຕັ້ງທາງເລືອກໃດນຶ່ງທີ່ອະນຸຍາດໂດຍ
driver... ເບິ່ງ "DBD::Pg" ແລະ "DBD:mysql" ຄູ່ມືສໍາລັບທາງເລືອກຕ່າງໆທີ່ສາມາດເປັນ.
ກໍານົດໂດຍຜ່ານຂໍ້ມູນສະເພາະຂອງແຫຼ່ງຂໍ້ມູນ DBI. ຢ່າງໃດກໍຕາມ, ເຄື່ອງແມ່ຂ່າຍຂອງຖານຂໍ້ມູນໄດ້ລະບຸໄວ້
ໃນ URL ຈະຕ້ອງສອດຄ່ອງກັບຂໍ້ມູນສະເພາະຂອງແຫຼ່ງນີ້ເພື່ອໃຫ້ການສອບຖາມ '
syntax ແມ່ນຖືກຕ້ອງ.

ຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອອີງໃສ່ສອງອາກິວເມັນ URL.

"--skip-inserts", "--skip-updates", "--skip-deletes"
ເມື່ອ synchronizing, ຢ່າປະຕິບັດການເຫຼົ່ານີ້.

ຄ່າເລີ່ມຕົ້ນພາຍໃຕ້ "--synchronize" ແມ່ນເພື່ອດໍາເນີນການທັງຫມົດ.

"--stats=(txt|csv)"
ສະແດງສະຖິຕິຕ່າງໆກ່ຽວກັບການປຽບທຽບທີ່ດໍາເນີນໃນຮູບແບບນີ້. ນອກຈາກນີ້, ທາງເລືອກ
"--stats-name" ໃຫ້ການທົດສອບຊື່, ທີ່ເປັນປະໂຫຍດໃນການສ້າງໄຟລ໌ csv ທີ່ຈະເປັນ
ປະມວນຜົນອັດຕະໂນມັດ.

ເລີ່ມຕົ້ນແມ່ນ ບໍ່ ເພື່ອສະແດງໃຫ້ເຫັນສະຖິຕິ, ເນື່ອງຈາກວ່າມັນຮຽກຮ້ອງໃຫ້ມີ synchronization ເພີ່ມເຕີມແລະ
ບໍ່ຈໍາເປັນຕ້ອງຫນ້າສົນໃຈກັບຜູ້ໃຊ້.

"--synchronize" ຫຼື "-S"
ປະຕິບັດການປະຕິບັດຕົວຈິງເພື່ອ synchronize ຕາຕະລາງທີສອງ wrt ທໍາອິດ. ດີ, ບໍ່ແມ່ນ
ແທ້ຈິງແລ້ວ, ມັນເປັນພຽງແຕ່ການແລ່ນແຫ້ງ. ຕົວຈິງແລ້ວມັນແມ່ນເຮັດໄດ້ຖ້າທ່ານເພີ່ມ "--do-it" ຫຼື "-D". ບັນທຶກ
ຂໍ້ມູນຂອງທ່ານກ່ອນທີ່ຈະພະຍາຍາມອັນນັ້ນ!

ຄ່າເລີ່ມຕົ້ນບໍ່ແມ່ນເພື່ອ synchronize.

"--ຊົ່ວຄາວ", "--ບໍ່ຊົ່ວຄາວ"
ວ່າຈະໃຊ້ຕາຕະລາງຊົ່ວຄາວຫຼືບໍ່. ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ບໍ່​ໄດ້​, ຕາ​ຕະ​ລາງ​ແມ່ນ​ໄດ້​ຖືກ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໃນ​ຕອນ​ຕົ້ນ​ທີ່​
ສຸດທ້າຍ, ດັ່ງນັ້ນເຂົາເຈົ້າຈະຕ້ອງຖືກລຶບດ້ວຍມື. ເບິ່ງ "-- clear" ທາງເລືອກທີ່ຈະຮ້ອງຂໍໃຫ້ມີ
ອະນາໄມ. ທາງເລືອກນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການ debugging.

ຄ່າເລີ່ມຕົ້ນແມ່ນການໃຊ້ຕາຕະລາງຊົ່ວຄາວທີ່ຈະຖືກລຶບລ້າງໂດຍອັດຕະໂນມັດເມື່ອ
ການເຊື່ອມຕໍ່ຖືກປິດ.

"--unlogged", "--no-unlogged"
ໃຊ້ຕາຕະລາງທີ່ບໍ່ໄດ້ບັນທຶກສໍາລັບການເກັບຮັກສາ checksums. ຕາຕະລາງເຫຼົ່ານີ້ບໍ່ແມ່ນການເຮັດທຸລະກໍາ, ດັ່ງນັ້ນມັນ
ອາດຈະເລັ່ງສິ່ງຕ່າງໆເລັກນ້ອຍ. ຢ່າງ​ໃດ​ກໍ​ຕາມ​, ພວກ​ເຂົາ​ເຈົ້າ​ບໍ່​ໄດ້​ຖືກ​ທໍາ​ຄວາມ​ສະ​ອາດ​ອັດ​ຕະ​ໂນ​ມັດ​ຢູ່​ໃນ​
ສິ້ນສຸດ. ເບິ່ງຕົວເລືອກ "--clear" ເພື່ອຮ້ອງຂໍການທໍາຄວາມສະອາດ.

ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ໃຫ້ໃຊ້ຕາຕະລາງທີ່ບໍ່ໄດ້ບັນທຶກ.

"-- threads" ຫຼື "-T", "--no-threads" ຫຼື "-N"
ຄຸນ​ນະ​ສົມ​ບັດ​ການ​ທົດ​ລອງ​ສູງ​.

ພະຍາຍາມໃຊ້ກະທູ້ເພື່ອປະຕິບັດການຄິດໄລ່ແບບຂະຫນານ, ມີບາງ hocus-pocus ເນື່ອງຈາກວ່າ
perl thread model ເຮັດວຽກບໍ່ດີກັບ DBI. ກະທູ້ Perl ແມ່ນຂ້ອນຂ້າງຫນັກ
ແລະຊ້າ, ຄືກັບຂະບວນການສື່ສານຫຼາຍກ່ວາກະທູ້ທີ່ມີນ້ໍາຫນັກເບົາ, ແທ້ໆ.

ນີ້ບໍ່ໄດ້ເຮັດວຽກທັງຫມົດກັບ PostgreSQL. ມັນເຮັດວຽກບາງສ່ວນກັບ MySQL, ຢູ່ທີ່
ລາຄາປິດ "-- ທຸລະກໍາ".

ເລີ່ມຕົ້ນແມ່ນ ບໍ່ ການນໍາໃຊ້ກະທູ້, ເນື່ອງຈາກວ່າມັນບໍ່ໄດ້ເຮັດວຽກສໍາລັບຖານຂໍ້ມູນທັງຫມົດ.

"--ໝົດເວລາ n"
ການປຽບທຽບການໝົດເວລາຫຼັງຈາກ "n" ວິນາທີ.

ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ມີການໝົດເວລາ. ມີ​ຄວາມ​ອົດ​ທົນ.

"--ທຸລະກໍາ", "--ບໍ່ມີທຸລະກໍາ"
ບໍ່ວ່າຈະເປັນການຫໍ່ algorithm ທັງຫມົດໃນທຸລະກໍາດຽວ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການໃຊ້ການເຮັດທຸລະກໍາຫໍ່, ຍ້ອນວ່າມັນເບິ່ງຄືວ່າຈະໄວແລະປອດໄພກວ່າ
ເຮັດແນວນັ້ນ.

"--tuple-checksum='tcs'" ຫຼື "--tcs=..."
ໃຊ້ tuple checksum attribute ຂອງຊື່ນີ້, ເຊິ່ງຕ້ອງມີຢູ່ໃນ
ຕາຕະລາງປຽບທຽບ. ທາງ​ເລືອກ​ນີ້​ຮຽກ​ຮ້ອງ​ໃຫ້​ຕັ້ງ​ເປັນ "--use-key​" ຫຼື​
"--key-checksum=..." ຂ້າງເທິງ. ຄຸນສົມບັດ checksum ທີ່ສະໜອງໃຫ້ຕ້ອງບໍ່ປາກົດຢູ່ໃນ
ບັນຊີລາຍຊື່ຂອງຄໍລໍາທີ່ສໍາຄັນແລະມູນຄ່າ. ເບິ່ງພາກສ່ວນຕົວຢ່າງຂ້າງລຸ່ມນີ້ສໍາລັບວິທີການກໍານົດ a
checksum trigger.

ຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອສ້າງທັງ checksums ທີ່ສໍາຄັນແລະ tuple ທັນທີ.

"--use-key" ຫຼື "-u"
ບໍ່ວ່າຈະເປັນການນໍາໃຊ້ມູນຄ່າຂອງກະແຈໂດຍກົງເພື່ອແຈກຢາຍ tuples ລະຫວ່າງສາຂາ. ໄດ້
key ຈະຕ້ອງງ່າຍດາຍ, ຈໍານວນເຕັມ, ບໍ່ແມ່ນ NULL, ແລະແຈກຢາຍຢ່າງເທົ່າທຽມກັນ. ຖ້າທ່ານມີ
ກະແຈຫຼັກຂອງຈຳນວນເຕັມທີ່ແຜ່ຂະຫຍາຍຢ່າງສົມເຫດສົມຜົນ, ພິຈາລະນາໃຊ້ຕົວເລືອກນີ້ເພື່ອຫຼີກເວັ້ນເຄິ່ງຫນຶ່ງຂອງ
checksum ຕາຕະລາງການຄິດໄລ່ hash.

Default ແມ່ນເພື່ອ hash ທີ່ສໍາຄັນ, ດັ່ງນັ້ນເປັນການຈັດການປະເພດໃດ, ອົງປະກອບແລະການແຜ່ກະຈາຍ.

"--use-null", "--no-use-null"
ວ່າຈະໃຊ້ຂໍ້ມູນທີ່ຖັນຖືກປະກາດວ່າບໍ່ແມ່ນ NULL ເພື່ອເຮັດໃຫ້ງ່າຍ
ການຄິດໄລ່ໂດຍການຫຼີກເວັ້ນການໂທຫາ COALESCE ເພື່ອຈັດການກັບຄ່າ NULL.

ຄ່າເລີ່ມຕົ້ນແມ່ນການນໍາໃຊ້ຂໍ້ມູນນີ້, ໃນລາຄາຂອງການສອບຖາມ metadata ຕາຕະລາງ.

"--verbose" ຫຼື "-v"
ມີຄວາມສຸຂຸມກ່ຽວກັບສິ່ງທີ່ເກີດຂຶ້ນ. ຍິ່ງເຈົ້າຖາມຫຼາຍເທົ່າໃດ, ຍິ່ງເວົ້າຫຼາຍ.

ຄ່າເລີ່ມຕົ້ນແມ່ນຈະງຽບ, ດັ່ງນັ້ນການເຕືອນໄພທີ່ເປັນໄປໄດ້ຫຼືຄວາມຜິດພາດທີ່ໂດດເດັ່ນ.

"--version" ຫຼື "-V"
ສະແດງຂໍ້ມູນເວີຊັນ ແລະອອກ.

"-- where=..."
ເງື່ອນໄຂ SQL boolean ໃນ tuples ຕາຕະລາງສໍາລັບການປຽບທຽບບາງສ່ວນ. ເປັນປະໂຫຍດເພື່ອຫຼຸດຜ່ອນການ
load ຖ້າທ່ານຮູ້ວ່າຄວາມແຕກຕ່າງທີ່ຄາດໄວ້ຢູ່ໃນບາງສ່ວນຂອງຂໍ້ມູນຂອງທ່ານ, ເວົ້າວ່າ
time-stamped ມື້ນີ້ ... ສະພາບດຽວກັນແມ່ນຜ່ານທັງສອງດ້ານ, ດັ່ງນັ້ນທັງສອງຕາຕະລາງຕ້ອງ
ມີຄວາມຄ້າຍຄືກັນຫຼາຍເພື່ອໃຫ້ມັນເຮັດວຽກ. ນີ້ແມ່ນປົກກະຕິແລ້ວກໍລະນີ.

ຄ່າເລີ່ມຕົ້ນແມ່ນການປຽບທຽບຕາຕະລາງທັງຫມົດ.

ການໂຕ້ຖຽງ

ການໂຕ້ຖຽງທັງສອງອະທິບາຍການເຊື່ອມຕໍ່ຖານຂໍ້ມູນກັບ syntax ຄ້າຍຄື URL ຕໍ່ໄປນີ້, ບ່ອນທີ່
ວົງເລັບສີ່ຫຼ່ຽມໝາຍເຖິງພາກສ່ວນທາງເລືອກ. ຫຼາຍພາກສ່ວນແມ່ນທາງເລືອກທີ່ມີຄ່າເລີ່ມຕົ້ນ. ຕໍາ່ສຸດທີ່
ຂໍ້ກໍານົດທີ່ຖືກຕ້ອງ syntactically ແມ່ນ "/", ແຕ່ວ່າບໍ່ຈໍາເປັນຫມາຍຄວາມວ່າຫຍັງ
ເປັນປະໂຫຍດ.

[driver://][login[:pass]@][host][:port]/[base/[[schema.]table[?key[:cols]]]]

ເບິ່ງພາກຕົວຢ່າງຂ້າງລຸ່ມນີ້, ແລະຕົວເລືອກ "--source-*" ຂ້າງເທິງ.

ຈື່ໄວ້ວ່າບາງຄ່າເລີ່ມຕົ້ນທີ່ໃຊ້ໂດຍໄດເວີ DBI ອາດຈະມີການປ່ຽນແປງກັບສະເພາະຄົນຂັບ
ຕົວແປສະພາບແວດລ້ອມ, ແລະ DBI ຍັງສະຫນອງຄ່າເລີ່ມຕົ້ນຂອງຕົນເອງແລະ overrides, ດັ່ງນັ້ນແມ່ນຫຍັງ
ຕົວຈິງເກີດຂຶ້ນອາດຈະບໍ່ຈະແຈ້ງສະ ເໝີ ໄປ. ຄ່າເລີ່ມຕົ້ນສໍາລັບ URL ທີສອງສ່ວນໃຫຍ່ແມ່ນ
ເອົາມາຈາກ URL ທໍາອິດ.

ຄົນຂັບ
ໄດເວີຖານຂໍ້ມູນທີ່ຈະໃຊ້. ໃຊ້ pgsql ສໍາລັບ PostgreSQL, mysql ສໍາລັບ MySQL, sqlite ສໍາລັບ SQLite.
ຖານຂໍ້ມູນ heterogeneous ອາດຈະຖືກປຽບທຽບແລະ synchronized, ແນວໃດກໍ່ຕາມລະວັງ subtle
ບັນຫາການພິມ, ການເຂົ້າລະຫັດແລະການສົ່ງສັນຍານອາດຈະປ້ອງກັນການປຽບທຽບທີ່ຫຼາກຫຼາຍ ຫຼື
synchronizations ສໍາເລັດ. ຄ່າເລີ່ມຕົ້ນແມ່ນ pgsql ສໍາລັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດ, ແລະຄືກັນກັບ
ທໍາອິດສໍາລັບທີສອງ.

ສໍາລັບ SQLite, ພາກສ່ວນການກວດສອບຄວາມຖືກຕ້ອງຂອງ URL (ເຂົ້າສູ່ລະບົບ, ຜ່ານ, ໂຮດ, ພອດ) ແມ່ນຄາດວ່າຈະ
ເພື່ອໃຫ້ຫວ່າງເປົ່າ, ດັ່ງນັ້ນ URL ເຕັມຄວນຈະເບິ່ງຄືວ່າ:

sqlite:///base.db/table?key,col:other,columns

ຍິ່ງໄປກວ່ານັ້ນ, ການຕັ້ງຄ່າ PGC_SQLITE_LOAD_EXTENSION ສະພາບແວດລ້ອມຕົວແປກັບ
":"-separated shared object files loads into SQLite.

ເຂົ້າ​ສູ່​ລະ​ບົບ
ເຂົ້າສູ່ລະບົບເພື່ອໃຊ້ເມື່ອເຊື່ອມຕໍ່ກັບຖານຂໍ້ມູນ. ຄ່າເລີ່ມຕົ້ນແມ່ນຊື່ຜູ້ໃຊ້ສໍາລັບການເຊື່ອມຕໍ່ທໍາອິດ,
ແລະຄືກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບທີສອງ.

ຜ່ານ
ລະຫັດຜ່ານທີ່ຈະໃຊ້ເມື່ອເຊື່ອມຕໍ່ກັບຖານຂໍ້ມູນ. ໃຫ້ສັງເກດວ່າມັນເປັນຄວາມຄິດທີ່ບໍ່ດີທີ່ຈະໃສ່ a
ລະຫັດຜ່ານເປັນການໂຕ້ຖຽງຄໍາສັ່ງ. ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ມີສໍາລັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດ, ແລະ
ລະຫັດຜ່ານດຽວກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບທີສອງ if ການເຊື່ອມຕໍ່ເປົ້າຫມາຍດັ່ງກ່າວ
ໂຮດດຽວກັນ, ພອດແລະໃຊ້ການເຂົ້າສູ່ລະບົບດຽວກັນ. ເບິ່ງ "--ask-pass" ແລະ "--env-pass" ນຳ.
ຕົວເລືອກ

ເຈົ້າພາບ
ຊື່ເຈົ້າພາບ ຫຼື IP ເພື່ອເຊື່ອມຕໍ່ກັບ. ຄ່າເລີ່ມຕົ້ນແມ່ນສະຕຣິງຫວ່າງເປົ່າ, ຊຶ່ງຫມາຍຄວາມວ່າການເຊື່ອມຕໍ່ກັບ
ຖານຂໍ້ມູນຢູ່ໃນ localhost ທີ່ມີເຕົ້າຮັບ UNIX.

port
ພອດ TCP-IP ເພື່ອເຊື່ອມຕໍ່ກັບ. ຄ່າເລີ່ມຕົ້ນແມ່ນ 5432 ສໍາລັບ PostgreSQL ແລະ 3306 ສໍາລັບ MySQL.

ຖານ
ຖານຂໍ້ມູນຖານຂໍ້ມູນທີ່ຈະເຊື່ອມຕໍ່ກັບ. ຄ່າເລີ່ມຕົ້ນແມ່ນຊື່ຜູ້ໃຊ້ສໍາລັບການເຊື່ອມຕໍ່ທໍາອິດ. ຄ່າເລີ່ມຕົ້ນແມ່ນ
ຄືກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບການເຊື່ອມຕໍ່ທີສອງ. ສໍາລັບ SQLite, ໃຫ້ໄຟລ໌ຖານຂໍ້ມູນ
ຊື່. ເສັ້ນທາງແມ່ນພີ່ນ້ອງກັນໂດຍຄ່າເລີ່ມຕົ້ນ, ແຕ່ສາມາດເຮັດໃຫ້ສົມບູນໄດ້ໂດຍການ prepending an
ເພີ່ມເຕີມ '/':

sqlite:////var/cache/sqlite/base.db/table?...

schema.table
ອາດຈະເປັນຕາຕະລາງທີ່ມີຄຸນວຸດທິ schema ເພື່ອໃຊ້ສໍາລັບການປຽບທຽບ. ບໍ່ມີຄ່າເລີ່ມຕົ້ນສໍາລັບຄັ້ງທໍາອິດ
ການເຊື່ອມຕໍ່. ຄ່າເລີ່ມຕົ້ນແມ່ນຄືກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບການເຊື່ອມຕໍ່ທີສອງ.

ໃຫ້ສັງເກດວ່າ MySQL ບໍ່ມີ schemas, ແຕ່ strange ພຽງພໍຂອງເຂົາເຈົ້າ ຖານຂໍ້ມູນ ແນວຄວາມຄິດແມ່ນ
ຄືກັນກັບກ ໂຄງ, ດັ່ງນັ້ນ MySQL ກໍ່ບໍ່ມີ ຖານຂໍ້ມູນ, ເຖິງແມ່ນວ່າມີ
ບາງສິ່ງບາງຢ່າງຂອງຊື່ນັ້ນ. ຂ້ອຍຈະແຈ້ງບໍ?

ໃຊ້
ລາຍຊື່ຖັນຫຼັກທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດ. ຄ່າເລີ່ມຕົ້ນແມ່ນລະຫັດຫຼັກຂອງຕາຕະລາງສໍາລັບທໍາອິດ
ການເຊື່ອມຕໍ່. ຄ່າເລີ່ມຕົ້ນແມ່ນຄືກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບການເຊື່ອມຕໍ່ທີສອງ. ກະ​ແຈ
ບໍ່ສາມາດເຮັດໄດ້ ຫວ່າງເປົ່າ. ຖ້າທ່ານບໍ່ມີວິທີການກໍານົດ tuples ຂອງທ່ານ, ຫຼັງຈາກນັ້ນບໍ່ມີ
ຈຸດ​ໃນ​ການ​ຊອກ​ຫາ​ຄວາມ​ແຕກ​ຕ່າງ​.

ຄໍ
ລາຍຊື່ຖັນທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດເພື່ອປຽບທຽບ. ອາດຈະຫວ່າງເປົ່າ. ຄ່າເລີ່ມຕົ້ນແມ່ນຖັນທັງໝົດແຕ່
ໃຊ້ ສໍາລັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດ. ຄ່າເລີ່ມຕົ້ນແມ່ນຄືກັນກັບການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດສໍາລັບການເຊື່ອມຕໍ່ທີສອງ.
ຈົ່ງລະວັງວ່າ "...?key:" ຫມາຍເຖິງ cols ຫວ່າງເປົ່າ, ໃນຂະນະທີ່ "...?key" ກໍານົດຄ່າເລີ່ມຕົ້ນໂດຍ.
ການສອບຖາມ metadata ຕາຕະລາງ.

ຕົວຢ່າງ

ປຽບທຽບຕາຕະລາງ calvin ແລະ hobbes ໃນຄອບຄົວຖານຂໍ້ມູນກ່ຽວກັບ localhost, ດ້ວຍລະຫັດ id ແລະຖັນ
c1 ແລະ c2:

./pg_comparator /family/calvin?id:c1,c2 /family/hobbes

ປຽບທຽບຕາຕະລາງ calvin ໃນຖານຂໍ້ມູນເລີ່ມຕົ້ນໃນ localhost ແລະຕາຕະລາງດຽວກັນໃນຄ່າເລີ່ມຕົ້ນ
ຖານຂໍ້ມູນກ່ຽວກັບ sablons, ມີທີ່ສໍາຄັນ id ແລະຖັນ ຂໍ້ມູນ:

./pg_comparator localhost/family/calvin?id:data sablons/

synchronize ຕາຕະລາງ "ຜູ້ໃຊ້" ໃນຖານຂໍ້ມູນ "wikipedia" ຈາກ MySQL ໃນ "server1" ກັບ PostgreSQL ໃນ
"ເຊີບເວີ2".

./pg_comparator -S -D --ask-pass
mysql://calvin@server1/wikipedia/user pgsql://hobbes@server2/

ສໍາລັບ PostgreSQL, ທ່ານອາດຈະເພີ່ມກະແຈທີ່ຮັກສາໄວ້ ແລະ tuple checksums ເປັນ:

-- TABLE Foo(id SERIAL PRIMARY KEY, ຂໍ້ມູນ ... ບໍ່ແມ່ນ NULL);
-- ເພີ່ມຄີ ແລະ tuple checksum attributes
-- checksum ຫຼັກສາມາດຂ້າມໄດ້ຖ້າທ່ານໃຊ້ --use-key,
-- ເຊິ່ງກະແຈຕ້ອງເປັນຈຳນວນເຕັມທີ່ບໍ່ທຳມະດາ.
ປ່ຽນແປງຕາຕະລາງ Foo
ເພີ່ມ COLUMN key_cs INT4 ບໍ່ແມ່ນຄ່າເລີ່ມຕົ້ນ 0,
ເພີ່ມ COLUMN tup_cs INT8 ບໍ່ແມ່ນ NULL DEFAULT 0;
-- ຟັງຊັນເພື່ອປັບປຸງ tuple checksum
-- ຖ້າຄຸນລັກສະນະບາງອັນອາດຈະເປັນ NULL, ພວກມັນຈະຕ້ອງຖືກລວມເຂົ້າກັນ
ສ້າງຟັງຊັນ foo_cs() ກັບຄືນ TRIGGER ເປັນ $$
ເລີ່ມຕົ້ນ
-- ຄໍາ​ນວນ checksum ທີ່​ສໍາ​ຄັນ​
NEW.key_cs = cksum4(NEW.id);
-- ຄິດໄລ່ tuple checksum
NEW.tup_cs = cksum8(NEW.id || '|' || NEW.data);
ກັບຄືນໃໝ່;
ສິ້ນສຸດ; $$ LANGUAGE plpgsql;
-- ຕັ້ງ trigger ເພື່ອໂທຫາຟັງຊັນການອັບເດດ checksum
ສ້າງ TRIGGER foo_cs_trigger
ກ່ອນການອັບເດດ ຫຼືໃສ່ໃນ Foo
ສໍາລັບແຕ່ລະແຖວ EXECUTE PROCEDURE foo_cs();
-- ຖ້າຕາຕະລາງ Foo ບໍ່ຫວ່າງເປົ່າ,
-- ປັບປຸງເນື້ອໃນຂອງມັນເພື່ອກະຕຸ້ນການຄິດໄລ່ checksum
ອັບເດດ Foo SET id=id;

ຫຼັງຈາກນັ້ນ, ການປຽບທຽບໄວ, ເຊິ່ງບໍ່ຈໍາເປັນຕ້ອງຄິດໄລ່ຕາຕະລາງ checksum ເບື້ອງຕົ້ນ, ສາມາດເປັນ
ຮ້ອງຂໍດ້ວຍ:

./pg_comparator --tcs=tup_cs --kcs=key_cs
admin@server1/app/Foo?id:data hobbes@server2/

ເນື່ອງຈາກລະຫັດຫຼັກແມ່ນຈໍານວນເຕັມທີ່ງ່າຍດາຍ, the key_cs ສາມາດຖືກປະຖິ້ມໄວ້ແລະການປຽບທຽບ
ສາມາດເປີດຕົວດ້ວຍ:

./pg_comparator --tcs=tup_cs --use-key
admin@server1/app/Foo?id:data hobbes@server2/

OUTPUT

ຜົນ​ຜະ​ລິດ​ຂອງ​ຄໍາ​ສັ່ງ​ປະ​ກອບ​ດ້ວຍ​ເສັ້ນ​ອະ​ທິ​ບາຍ​ຄວາມ​ແຕກ​ຕ່າງ​ທີ່​ພົບ​ເຫັນ​ລະ​ຫວ່າງ​
ສອງຕາຕະລາງ. ພວກມັນສະແດງອອກໃນລັກສະນະການແຊກ, ການປັບປຸງຫຼືການລົບແລະ tuple
keys

UPDATE k
ທີ່ສໍາຄັນ k tuple ຖືກປັບປຸງຈາກຕາຕະລາງ 1 ຫາຕາຕະລາງ 2. ມັນມີຢູ່ໃນຕາຕະລາງທັງສອງທີ່ມີ
ຄຸນ​ຄ່າ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​.

INSERT k
ທີ່ສໍາຄັນ k tuple ບໍ່ປາກົດຢູ່ໃນຕາຕະລາງ 2, ແຕ່ວ່າພຽງແຕ່ຢູ່ໃນຕາຕະລາງ 1. ມັນຕ້ອງຖືກໃສ່ໃນ
ຕາຕະລາງ 2 ເພື່ອ synchronize ມັນ wrt ຕາຕະລາງ 1.

DELETE k
ທີ່ສໍາຄັນ k tuple ປາກົດຢູ່ໃນຕາຕະລາງ 2, ແຕ່ບໍ່ແມ່ນຢູ່ໃນຕາຕະລາງ 1. ມັນຕ້ອງຖືກລົບຈາກ 2 ເຖິງ
synchronize ມັນ wrt ຕາ​ຕະ​ລາງ 1​.

ໃນກໍລະນີຂອງ tuple checksum collisions, ຜົນໄດ້ຮັບທາງລົບທີ່ບໍ່ຖືກຕ້ອງອາດຈະເກີດຂຶ້ນ. ການ​ປ່ຽນ​ແປງ​
ຟັງຊັນ checksum ຈະຊ່ວຍໃນກໍລະນີດັ່ງກ່າວ. ເບິ່ງພາກສ່ວນຍ່ອຍຂອງການວິເຄາະ.

ການເພິ່ງພາອາໄສ

ສາມຫນ້າທີ່ສະຫນັບສະຫນູນແມ່ນຈໍາເປັນໃນຖານຂໍ້ມູນ:

1.
ຟັງຊັນ "COALESCE" ເບິ່ງແຍງຄ່າ NULL ໃນຖັນ.

2.
ຟັງຊັນ checksum ຕ້ອງຖືກໃຊ້ເພື່ອຫຼຸດ ແລະແຈກຢາຍຄ່າຄີ ແລະຖັນ. ມັນອາດຈະ
ມີການປ່ຽນແປງດ້ວຍຕົວເລືອກ "--checksum". ຂະຫນາດຂອງມັນສາມາດເລືອກໄດ້ດ້ວຍ
"--checksize" ທາງເລືອກ (ປະຈຸບັນ 2, 4 ຫຼື 8 bytes). checksums ຍັງຕ້ອງການສຽງໂຫວດທັງຫມົດ
ປ່ຽນເປັນຈຳນວນຫຼາຍຂະໜາດ.

ການປະຕິບັດທີ່ເຫມາະສົມແມ່ນມີຢູ່ສໍາລັບ PostgreSQL ແລະສາມາດໂຫລດເຂົ້າໄປໃນເຄື່ອງແມ່ຂ່າຍ
ໂດຍການປະມວນຜົນ "share/contrib/pgc_checksum.sql" ແລະ "share/contrib/pgc_casts.sql". ໃຫມ່
checksums ແລະ casts ຍັງມີສໍາລັບ MySQL, ເບິ່ງ "mysql_*.sql". ສາມາດໂຫຼດໄດ້
ການປະຕິບັດຫນ້າທີ່ checksum ທີ່ເຫມາະສົມຍັງມີຢູ່ສໍາລັບ SQLite, ເບິ່ງ
"sqlite_checksum.*".

"ck" checksum ແມ່ນອີງໃສ່ Jenkins hash ,
ເຊິ່ງອາໄສການເພີ່ມ, shift ແລະ xor integer ງ່າຍໆ. ການກວດສອບ "fnv" ແມ່ນ
ດົນໃຈໂດຍ FNV hash (64 ບິດ 1a
version) ເຊິ່ງໃຊ້ xor ແລະ mult integer operations, ເຖິງແມ່ນວ່າຂ້ອຍຍັງໄດ້ເພີ່ມ shift ບາງຢ່າງ
ແລະເພີ່ມເພື່ອຊ່ວຍປັບບິດສູງ.

3.
ຟັງຊັນລວມແມ່ນໃຊ້ເພື່ອສະຫຼຸບ checksums ສໍາລັບແຖວເກັດທີ່ຢູ່. ມັນຕ້ອງ
ດໍາເນີນການກ່ຽວກັບຜົນໄດ້ຮັບຂອງຫນ້າທີ່ checksum. ມັນອາດຈະມີການປ່ຽນແປງກັບ
ທາງເລືອກ "-- ລວມ".

ການປະຕິບັດທີ່ເຫມາະສົມຂອງການລວບລວມສະເພາະ - ຫຼື "xor" ແມ່ນມີຢູ່ສໍາລັບ PostgreSQL
ແລະສາມາດໂຫລດເຂົ້າໄປໃນເຄື່ອງແມ່ຂ່າຍໂດຍການປະມວນຜົນ "share/contrib/xor_aggregate.sql".

ໄຟລ໌ "sqlite_checksum.*" ຍັງສະຫນອງ "xor" ແລະ "sum" ລວມສໍາລັບ SQLite ທີ່.
ແມ່ນເຂົ້າກັນໄດ້ກັບຖານຂໍ້ມູນອື່ນໆ.

ຍິ່ງໄປກວ່ານັ້ນ, ໂມດູນ perl ຫຼາຍແມ່ນເປັນປະໂຫຍດເພື່ອແລ່ນສະຄິບນີ້:

· "Getopt::Long" ສໍາລັບການຈັດການທາງເລືອກ.

· "DBI", "DBD::Pg" ເພື່ອເຊື່ອມຕໍ່ກັບ PostgreSQL, "DBD::mysql" ເພື່ອເຊື່ອມຕໍ່ກັບ MySQL, ແລະ
"DBD::SQLite" ເພື່ອເຊື່ອມຕໍ່ກັບ SQLite.

· "Term::ReadPassword" ສໍາລັບ "--ask-pass" ທາງເລືອກ.

· "Pod::Usage" for doc self-extraction ("--man" "--opt" "--help").

· "ກະທູ້" ສໍາລັບສະບັບທົດລອງ threaded ທີ່ມີທາງເລືອກ "--threads".

· "Digest::MD5" ສໍາລັບ md5 checksum ກັບ SQLite.

ໂມດູນຖືກໂຫລດໂດຍສະຄິບເທົ່ານັ້ນຖ້າພວກເຂົາຕ້ອງການຕົວຈິງ.

ອັລເກີຣິດ

ຈຸດປະສົງຂອງ algorithm ແມ່ນເພື່ອປຽບທຽບເນື້ອໃນຂອງສອງຕາຕະລາງ, ອາດຈະແຕກຕ່າງກັນ
ເຊີບເວີຫ່າງໄກສອກຫຼີກ, ມີການຈະລາຈອນເຄືອຂ່າຍຕໍາ່ສຸດທີ່. ມັນໄດ້ຖືກປະຕິບັດໃນສາມໄລຍະ.

1.
ຕາຕະລາງ checksum ຖືກຄິດໄລ່ໃນແຕ່ລະດ້ານສໍາລັບຕາຕະລາງເປົ້າຫມາຍ.

2.
ຕາ​ຕະ​ລາງ​ສະ​ຫຼຸບ​ລະ​ດັບ fist ແມ່ນ​ຄໍາ​ນວນ​ຢູ່​ໃນ​ແຕ່​ລະ​ດ້ານ​ໂດຍ​ການ​ລວບ​ລວມ chunks ຂອງ​
ຕາຕະລາງ checksum. ລະດັບອື່ນໆຂອງການລວບລວມສະຫຼຸບແມ່ນປະຕິບັດຈົນກ່ວາມີ
ພຽງແຕ່ຫນຶ່ງແຖວໃນຕາຕະລາງສຸດທ້າຍ, ເຊິ່ງຫຼັງຈາກນັ້ນເກັບຮັກສາ checksum ທົ່ວໂລກສໍາລັບທັງຫມົດ
ຕາຕະລາງເປົ້າຫມາຍເບື້ອງຕົ້ນ.

3.
ເລີ່ມຕົ້ນຈາກຕາຕະລາງສະຫຼຸບຂ້າງເທິງ, ການກວດສອບລວມແມ່ນປຽບທຽບຈາກທັງສອງ
ທັງສອງດ້ານເພື່ອຊອກຫາຄວາມແຕກຕ່າງ, ລົງໄປຫາຕາຕະລາງ checksum ເບື້ອງຕົ້ນ. ກຸນແຈຂອງຄວາມແຕກຕ່າງ
tuples ແມ່ນສະແດງ.

ກວດເຊັກ ຕາຕະລາງ
ໄລຍະທໍາອິດຄິດໄລ່ຕາຕະລາງ checksum ເບື້ອງຕົ້ນ T(0​) ໃນແຕ່ລະດ້ານ. ສົມມຸດວ່າ ທີ່ສໍາຄັນ
ແມ່ນຖັນຫຼັກຂອງຕາຕະລາງ, ແລະ ຄໍ ແມ່ນຖັນຂໍ້ມູນຕາຕະລາງທີ່ຈະຕ້ອງກວດສອບ
ຄວາມແຕກຕ່າງ, ຫຼັງຈາກນັ້ນມັນຖືກປະຕິບັດໂດຍການສອບຖາມຕາຕະລາງເປົ້າຫມາຍ T ດັ່ງຕໍ່ໄປນີ້:

ສ້າງຕາຕະລາງ T(0) AS
SELECT key AS pk, -- ລະຫັດຫຼັກ
checksum(key) AS kcs, -- key checksum
checksum(key || cols) AS tcs -- tuple checksum
FROM t;

ກະແຈເບື້ອງຕົ້ນຖືກເກັບຮັກສາໄວ້, ຍ້ອນວ່າມັນຈະຖືກໃຊ້ເພື່ອສະແດງກະແຈທີ່ແຕກຕ່າງກັນໃນຕອນທ້າຍ. ໄດ້
ສົມ​ເຫດ​ສົມ​ຜົນ​ສໍາ​ລັບ​ການ​ kcs ຖັນແມ່ນເພື່ອ Randomize ການແຈກຢາຍ key-values ​​ເພື່ອຄວາມສົມດຸນ
ລວມກັນໃນໄລຍະຕໍ່ໄປ. ກຸນແຈຕ້ອງປາກົດຢູ່ໃນ checksum ເຊັ່ນກັນ, ຖ້າບໍ່ດັ່ງນັ້ນເນື້ອຫາ
ການແລກປ່ຽນລະຫວ່າງສອງກະແຈຈະບໍ່ຖືກກວດພົບໃນບາງກໍລະນີ.

ບົດສະຫຼຸບ ຕາຕະລາງ
ໃນປັດຈຸບັນພວກເຮົາຄິດໄລ່ຊຸດຂອງຕາຕະລາງສະຫຼຸບ cascading ໂດຍການຈັດກຸ່ມ f (ປັດໄຈພັບ) checksums
ຮ່ວມກັນໃນແຕ່ລະຂັ້ນຕອນ. ການຈັດກຸ່ມແມ່ນອີງໃສ່ໜ້າກາກໃສ່ kcs ຖັນທີ່ຈະເອົາ
ປະໂຫຍດຂອງການສຸ່ມ checksum. ເລີ່ມແຕ່ p = 0 ພວກເຮົາສ້າງ:

ສ້າງຕາຕະລາງ T(p+1) AS
SELECT kcs & mask(p+1) AS kcs, -- key checksum subset
XOR(tcs) AS tcs -- tuple checksum ສະຫຼຸບ
ຈາກ T(p)
ກຸ່ມໂດຍ kcs & ຫນ້າກາກ(p+1);

ຫນ້າກາກ (p) ຖືກກໍານົດເພື່ອໃຫ້ມັນຈັດກຸ່ມເຂົ້າກັນໂດຍສະເລ່ຍ f checksums ຮ່ວມ​ກັນ​: ຫນ້າກາກ(0​)
= ceil2(ຂະຫນາດ); ຫນ້າກາກ(p) = ຫນ້າກາກ(p-1)/f; ນີ້ນໍາໄປສູ່ການລໍາດັບຊັ້ນຂອງຕາຕະລາງ, ແຕ່ລະຄົນເປັນ
ສະຫຼຸບຫຍໍ້ຂອງອັນກ່ອນໜ້ານີ້:

ລະດັບ 0
ຕາ​ຕະ​ລາງ checksum​, ຂະຫນາດ ແຖວ, ie ຫຼາຍແຖວເປັນຕາຕະລາງເປົ້າຫມາຍ.

ລະດັບ 1
ຕາຕະລາງສະຫຼຸບທໍາອິດ, (ຂະຫນາດ / f) ແຖວ.

ລະດັບ p
ຕາຕະລາງສະຫຼຸບລະດັບປານກາງ, (size/f**p) ແຖວ.

ລະດັບ n-1
ຫນຶ່ງກ່ອນຕາຕະລາງສະຫຼຸບສຸດທ້າຍ, ຫນ້ອຍກວ່າ f ແຖວ.

ລະດັບ n
ຕາຕະລາງສະຫຼຸບສຸດທ້າຍ, ຫນ້າກາກແມ່ນ 0, 1 ແຖວ.

ມັນເປັນສິ່ງສໍາຄັນທີ່ຫນ້າກາກດຽວກັນຖືກນໍາໃຊ້ທັງສອງດ້ານເພື່ອໃຫ້ການລວບລວມ
ດຽວກັນ, ອະນຸຍາດໃຫ້ປຽບທຽບເນື້ອໃນທີ່ກົງກັນຂອງທັງສອງດ້ານ.

ຄົ້ນຫາ FOR ຄວາມແຕກຕ່າງ
ຫຼັງຈາກຕາຕະລາງສະຫນັບສະຫນູນທັງຫມົດເຫຼົ່ານີ້ຖືກສ້າງຂຶ້ນໃນທັງສອງດ້ານ, ການຄົ້ນຫາສໍາລັບຄວາມແຕກຕ່າງ.
ເມື່ອກວດເບິ່ງສະຫຼຸບສັງລວມຂອງຕາຕະລາງສຸດທ້າຍ (ລະດັບ n) ມີພຽງແຕ່ແຖວດຽວ, ມັນແມ່ນ
ໂດຍພື້ນຖານແລ້ວແມ່ນການປຽບທຽບ checksum ຂອງເນື້ອໃນຕາຕະລາງທັງຫມົດ. ຖ້າພວກເຂົາກົງກັນ, ຫຼັງຈາກນັ້ນ
ຕາຕະລາງທັງສອງແມ່ນເທົ່າທຽມກັນ, ແລະພວກເຮົາເຮັດແລ້ວ. ຖ້າບໍ່ດັ່ງນັ້ນ, ຖ້າ checksums ເຫຼົ່ານີ້ແຕກຕ່າງກັນ, ບາງ
ຈໍາເປັນຕ້ອງໄດ້ສືບສວນເພື່ອກວດຫາກະແຈທີ່ກະທຳຜິດ.

ການສືບສວນແມ່ນປະຕິບັດໂດຍການລົງລໍາດັບຊັ້ນຂອງຕາຕະລາງແລະຊອກຫາທັງຫມົດ kcs
ສໍາລັບການທີ່ມີຄວາມແຕກຕ່າງໃນ checksum ໃນລະດັບທີ່ຜ່ານມາ. ຄໍາຖາມດຽວກັນແມ່ນ
ປະຕິບັດທັງສອງດ້ານໃນແຕ່ລະຂັ້ນຕອນ:

ເລືອກ kcs, tcs
ຈາກ T(p)
ບ່ອນທີ່ kcs & mask(p+1) IN (kcs-with-diff-checksums-from-level-p+1)
ສັ່ງໂດຍ kcs [ແລະໃນລະດັບ 0: , id];

ແລະຜົນໄດ້ຮັບຈາກທັງສອງຝ່າຍໄດ້ຖືກລວມເຂົ້າກັນ. ໃນ​ເວ​ລາ​ທີ່​ເຮັດ​ຂັ້ນ​ຕອນ​ການ​ລວມ​, ສີ່​
ກໍ​ລະ​ນີ​ສາ​ມາດ​ເກີດ​ຂຶ້ນ​:

1.
ທັງສອງ kcs ແລະ tcs ກົງກັນ. ຫຼັງຈາກນັ້ນ, ບໍ່ມີຄວາມແຕກຕ່າງກັນ.

2.
ເຖິງແມ່ນວ່າ kcs ກົງ​ກັນ​, tcs ບໍ່. ແລ້ວນີ້ kcs ແມ່ນ​ຈະ​ສືບ​ສວນ​ໃນ​ຂັ້ນ​ຕໍ່​ໄປ
ລະດັບ, ຍ້ອນວ່າການສະຫຼຸບ checksum ແຕກຕ່າງກັນ. ຖ້າພວກເຮົາຢູ່ໃນລະດັບສຸດທ້າຍ, ຫຼັງຈາກນັ້ນ
ກະແຈທີ່ກະທໍາຜິດສາມາດສະແດງໄດ້.

3.
No kcs ກົງກັນ, ຫນຶ່ງເພີ່ມເຕີມ kcs ໃນດ້ານທໍາອິດ. ແລ້ວນີ້ kcs ກົງກັບ
ຄີ (s) ທີ່ຕ້ອງຖືກໃສ່ເພື່ອ syncing ຕາຕະລາງທີສອງ wrt ທໍາອິດ.

4.
No kcs ກົງກັນ, ຫນຶ່ງເພີ່ມເຕີມ kcs ໃນດ້ານທີສອງ. ແລ້ວນີ້ kcs ກົງກັບ
ຄີ (s) ທີ່ຕ້ອງຖືກລົບສໍາລັບການ sync ຕາຕະລາງທີສອງ wrt ທໍາອິດ.

ກໍລະນີທີ 3 ແລະ 4 ແມ່ນສົມມາທິກັນແບບງ່າຍໆ, ແລະມັນເປັນພຽງການຕີຄວາມໝາຍເພື່ອຕັດສິນໃຈວ່າ
ມັນ​ເປັນ​ການ​ແຊກ​ຫຼື​ລົບ​, ການ​ເອົາ​ດ້ານ​ທໍາ​ອິດ​ເປັນ​ກະ​ສານ​ອ້າງ​ອີງ​.

ANALYSIS
ໃຫ້ n ເປັນ​ຈໍາ​ນວນ​ຂອງ​ແຖວ​, r ຂະ​ຫນາດ​ແຖວ​, f ປັດໄຈພັບ, k ຈໍາ​ນວນ​ຂອງ
ຄວາມ​ແຕກ​ຕ່າງ​ທີ່​ຈະ​ກວດ​ພົບ​, c ຂະຫນາດ checksum ໃນ bits, ຫຼັງຈາກນັ້ນຄ່າໃຊ້ຈ່າຍໃນການກໍານົດ
ຄວາມແຕກຕ່າງແລະອັດຕາຄວາມຜິດພາດແມ່ນ:

ເຄືອຂ່າຍ ປະລິມານ
ແມ່ນດີກ່ວາ k*f*ceil(log(n)/log(f))*(c+log(n)). ເນື້ອໃນຂອງ k ຕັນຂອງຂະຫນາດ f
ໄດ້ຖືກໂອນຢູ່ໃນຄວາມເລິກຂອງຕົ້ນໄມ້, ແລະແຕ່ລະຕົວກໍານົດຕັນແມ່ນຂະຫນາດ ທ່ອນ ແລະ
ມີ checksum c. ມັນເປັນເອກະລາດຂອງ r, ແລະທ່ານຕ້ອງການ k<< ນ. ປະລິມານຂອງ
ການຮ້ອງຂໍ SQL ແມ່ນກ່ຽວກັບ k*log(n)*ceil(log(n)/log(f)), ເປັນບັນຊີລາຍຊື່ທີ່ບໍ່ກົງກັນ
ດ່ານກວດກາ k*log(n) ອາດ​ຈະ​ຖືກ dragged ໃນ​ຄວາມ​ເລິກ​ຂອງ​ຕົ້ນ​ໄມ້​.

ຈໍານວນ of ການຮ້ອງຂໍ (ສຸດ ແຕ່ລະຄົນ ຂ້າງ, ໄດ້ ຂັ້ນຕອນວິທີ is ສົມມາດ)
ຕໍາ່ສຸດທີ່ 6+ceil(log(n)/log(f)) ສໍາລັບຕາຕະລາງເທົ່າທຽມກັນ, ສູງສຸດແມ່ນ 6+2*ceil(log(n)/log(f)).

ແຜ່ນ ຂ້າພະເຈົ້າ / O ການຈະລາຈອນ
ກ່ຽວ​ກັບ n*r+n*ln(n)*(f/(f-1)).

ທີ່ບໍ່ຖືກຕ້ອງ ກະທົບທາງລົບ ການຄາດຄະເນ
ie ສ່ວນຫນຶ່ງຂອງຕາຕະລາງແມ່ນຖືວ່າເທົ່າທຽມກັນເຖິງແມ່ນວ່າພວກມັນແຕກຕ່າງກັນ. ດ້ວຍ ກ
ຟັງຊັນ checksum ທີ່ສົມບູນແບບ, ນີ້ແມ່ນຄວາມເປັນໄປໄດ້ຂອງການ collision checksum ໃນຈຸດໃດ
ບ່ອນທີ່ພວກເຂົາຖືກຄິດໄລ່ແລະຄວນຈະແຕກຕ່າງກັນ: ກ່ຽວກັບ
k*ceil(log(n)/log(f))*2**-c. ສໍາລັບຕາຕະລາງລ້ານແຖວ, ຄາດວ່າຈະມີການປ່ຽນແປງ 1000 ກັບ the
ຄ່າພາລາມິເຕີ algorithm ເລີ່ມຕົ້ນ, ນີ້ແມ່ນກ່ຽວກັບ 2 ** 10 *3/2**64, ນັ້ນແມ່ນປະມານຫນຶ່ງ
ໂອກາດໃນ 2 ** 52 ລວມແລ່ນ.

ປັດໄຈການພັບຕ່ໍາກວ່າ f ທີ່ດີກວ່າສໍາລັບປະລິມານເຄືອຂ່າຍ, ແຕ່ສູງກວ່າ
ທີ່​ດີກ​ວ່າ​ສໍາ​ລັບ​ຈໍາ​ນວນ​ຂອງ​ການ​ຮ້ອງ​ຂໍ​ແລະ​ແຜ່ນ I/Os​: ທາງ​ເລືອກ​ຂອງ​ f ແມ່ນ​ການ​ແລກ​ປ່ຽນ.

ຂະຫນາດ checksum ຕ່ໍາກວ່າ c, ທີ່ດີກວ່າສໍາລັບປະລິມານເຄືອຂ່າຍ, ແຕ່ຮ້າຍແຮງກວ່າເກົ່າສໍາລັບ
ຄວາມເປັນໄປໄດ້ທາງລົບທີ່ບໍ່ຖືກຕ້ອງ.

ຖ້າແບນວິດທີ່ມີຢູ່ແມ່ນສົມເຫດສົມຜົນ, ການປຽບທຽບສ່ວນຫຼາຍອາດຈະຖືກຜູກມັດ cpu:
ເວລາແມ່ນໃຊ້ເວລາສ່ວນໃຫຍ່ໃນການຄິດໄລ່ຕາຕະລາງ checksum ເບື້ອງຕົ້ນ. ດັ່ງນັ້ນຖ້າຫາກວ່າທ່ານແມ່ນ
ການວາງແຜນທີ່ຈະກວດສອບຄວາມແຕກຕ່າງຂ້ອນຂ້າງເລື້ອຍໆ, ພິຈາລະນາຮັກສາ tuple checksum ກັບ
ຜົນກະທົບຕໍ່, ແລະອາດຈະເປັນ checksum ທີ່ສໍາຄັນເຊັ່ນດຽວກັນ, ແລະຮຽກຮ້ອງດ້ວຍ "--tuple-checksum" ແລະ
ທັງ "--key-checksum" ຫຼື "--use-key".

ການ ນຳ ໃຊ້ ບັນຫາ
ການປະຕິບັດ checksum ໃຫ້ຈໍານວນເຕັມ, ຊຶ່ງເປັນຄວາມຍາວຄົງທີ່ແລະງ່າຍທີ່ຈະ
ໝູນໃຊ້ພາຍຫຼັງ.

ໄດ້ xor ລວມເປັນທາງເລືອກທີ່ດີເພາະວ່າບໍ່ມີບັນຫາ overflow ກັບມັນ, ມັນໃຊ້ເວລາ
ເຂົ້າໄປໃນບັນຊີທັງຫມົດຂອງການປ້ອນຂໍ້ມູນ, ແລະມັນສາມາດຖືກກໍານົດໄດ້ຢ່າງງ່າຍດາຍກ່ຽວກັບຂໍ້ມູນຖານສອງ. ໄດ້
sum ລວມກັນກໍ່ບໍ່ເປັນຫຍັງ, ແຕ່ມັນຕ້ອງການບາງຊະນິດຂອງຈຳນວນເຕັມທີ່ຕິດພັນ.

ຄ່າ NULL ຕ້ອງໄດ້ຮັບການດູແລຢ່າງເຫມາະສົມ.

ປັດໄຈພັບແລະໂມດູນທັງຫມົດແມ່ນຖືເປັນພະລັງງານຂອງສອງເພື່ອນໍາໃຊ້ຫນ້າກາກ.

ມີການຈັດການພິເສດຂອງການຕັດຂະຫນາດໃຫຍ່ຂອງການລຶບຫຼືໃສ່ທີ່ໄດ້ຖືກປະຕິບັດ
ເຖິງແມ່ນວ່າບໍ່ມີລາຍລະອຽດໃນພາບລວມ algorithmic ແລະການວິເຄາະຄວາມສັບສົນ.

ມີຄວາມພະຍາຍາມບາງຢ່າງທີ່ຈະສ້າງການປະຕິບັດທີ່ເຫມາະສົມກັບ PostgreSQL / MySQL ຂອງ
algorithm, ເຊິ່ງໄດ້ເພີ່ມ hacks ເພື່ອຈັດການກັບການແປງປະເພດແລະສິ່ງອື່ນໆ.

script ນີ້ຖືກທົດສອບຢ່າງສົມເຫດສົມຜົນ, ແຕ່ເນື່ອງຈາກຫຼັກຖານສະແດງແນວຄວາມຄິດຂອງມັນມີຫຼາຍ
ທາງເລືອກໃນການລວມກັນທີ່ບໍ່ສາມາດທົດສອບໄດ້ທັງຫມົດ.

ຫມາຍ​ເຫດ​
ຖ້າຕາຕະລາງທີ່ຈະປຽບທຽບຢູ່ໃນຖານຂໍ້ມູນດຽວກັນ, ຄໍາຖາມ SQL ງ່າຍໆສາມາດສະກັດເອົາ
ຄວາມແຕກຕ່າງ. ຕາຕະລາງສົມມຸດ T1 ແລະ T2 ດ້ວຍລະຫັດຫຼັກ id ແລະເນື້ອໃນທີ່ບໍ່ແມ່ນ null ຂໍ້ມູນ,
ຫຼັງຈາກນັ້ນ, ຄວາມແຕກຕ່າງຂອງພວກເຂົາ, ນັ້ນແມ່ນແນວໃດ T2 ແຕກຕ່າງຈາກການອ້າງອີງ T1, ແມ່ນສະຫຼຸບໂດຍ
ຄຳຖາມຕໍ່ໄປນີ້:

ເລືອກ COALESCE(T1.id, T2.id) ເປັນກະແຈ,
ກໍລະນີເມື່ອ T1.id ເປັນ NULL ຫຼັງຈາກນັ້ນ 'ລຶບ'
ເມື່ອ T2.id ເປັນ NULL ແລ້ວ 'ໃສ່'
'ອັບເດດ' ອື່ນ
ສິ້ນສຸດ AS ການດໍາເນີນງານ
ຈາກ T1 ເຂົ້າຮ່ວມ T2 ເຕັມໂດຍໃຊ້ (id)
T1.id ຢູ່ໃສ NULL -- Delete
ຫຼື T2.id ແມ່ນ NULL -- ແຊກ
ຫຼື T1.data <> T2.data -- ອັບເດດ

ຂໍ້ມູນອ້າງອິງ
ເອກະສານໄດ້ຖືກນໍາສະເຫນີຢູ່ໃນກອງປະຊຸມກ່ຽວກັບເຄື່ອງມືນີ້ແລະວິທີການຂອງມັນ: ຫ່າງໄກສອກຫຼີກ ປຽບທຽບ
of ຖານຂໍ້ມູນ ຕາຕະລາງ by Fabian Bunny, ໃນກອງປະຊຸມສາກົນຄັ້ງທີສາມກ່ຽວກັບຄວາມກ້າວຫນ້າໃນ
ຖານຂໍ້ມູນ, ຄວາມຮູ້ ແລະການນຳໃຊ້ຂໍ້ມູນ (DBKDA), pp 23-28, St Marteen, The Netherlands
Antilles, ມັງກອນ 2011. ISBN: 978-1-61208-002-4. ລິຂະສິດ IARIA 2011. ອອນລາຍຢູ່ Think
ໃຈhttp://www.thinkmind.org/index.php?view=article&articleid=dbkda_2011_2_10_30021>.

ສູດການຄິດໄລ່ແລະ script ໄດ້ຮັບການດົນໃຈໂດຍ ການຄວບຄຸມ ໄດ້ ຖືກແຈກຢາຍ ຖານຂໍ້ມູນ ບັນຫາ: A ກໍລະນີ
ການ​ສຶກ​ສາ ການນໍາໃຊ້ MySQL by Giuseppe Maxia in ສ Admin vol 13 ເລກທີ 8, ສິງຫາ 2004, ຫນ້າ 29-40. ເບິ່ງ
Perl Monkshttp://www.perlmonks.org/index.pl?node_id=381053> ສໍາລັບລາຍລະອຽດ. ໃນເອກະສານສະບັບນີ້,
ສາມ algorithms ຖືກນໍາສະເຫນີ. ອັນທໍາອິດປຽບທຽບສອງຕາຕະລາງທີ່ມີ checksum
ເຕັກນິກ. ອັນທີສອງພົບວ່າ UPDATE ຫຼື INSERT ຄວາມແຕກຕ່າງໂດຍອີງໃສ່ 2 ລະດັບ (checksum
ແລະສະຫຼຸບ) ການຈັດລໍາດັບຕາຕະລາງ. ສູດການຄິດໄລ່ແມ່ນບໍ່ສົມມາດ, ເປັນການສອບຖາມທີ່ແຕກຕ່າງກັນ
ປະຕິບັດຢູ່ໃນສອງຕາຕະລາງເພື່ອປຽບທຽບ. ມັນເບິ່ງຄືວ່າປະລິມານການຈະລາຈອນເຄືອຂ່າຍແມ່ນຢູ່ໃນ
k*(f+(n/f)+r), ວ່າມັນມີຂັ້ນຕອນການຜະສົມຜະສານທີ່ອາດຈະເປັນໄປໄດ້-buggy, ແລະວ່າມັນເຮັດໃຫ້
ສົມມຸດຕິຖານກ່ຽວກັບການແຈກຢາຍຄ່າທີ່ສໍາຄັນ. ສູດການຄິດໄລ່ທີສາມຊອກຫາ DELETE
ຄວາມແຕກຕ່າງໂດຍອີງໃສ່ການນັບ, ໂດຍສົມມຸດຕິຖານ implicit ວ່າມີພຽງແຕ່ດັ່ງກ່າວ
ຄວາມແຕກຕ່າງ.

ໃນທາງກົງກັນຂ້າມກັບວິທີການນີ້, ສູດການຄິດໄລ່ symmetrical ຂອງພວກເຮົາປະຕິບັດທັງສາມວຽກງານ
ໃນເວລາດຽວກັນ, ເພື່ອຊອກຫາ UPDATE, DELETE ແລະ INSERT ລະຫວ່າງສອງຕາຕະລາງ. checksum ແລະ
ແນວຄວາມຄິດລະດັບລໍາດັບຂັ້ນສະຫຼຸບແມ່ນຖືກນໍາໃຊ້ຄືນໃຫມ່ແລະໂດຍທົ່ວໄປເພື່ອຫຼຸດຜ່ອນສູດການຄິດໄລ່
ຄວາມສັບສົນ.

ຈາກທັດສະນະການຈັດຕັ້ງປະຕິບັດ, script ແມ່ນ parametric ເທົ່າທີ່ເປັນໄປໄດ້ກັບຫຼາຍໆຄົນ
ທາງເລືອກ, ແລະເຮັດໃຫ້ສົມມຸດຕິຖານຈໍານວນຫນ້ອຍກ່ຽວກັບໂຄງສ້າງຕາຕະລາງ, ປະເພດແລະຄຸນຄ່າ.

ໃຊ້ pg_comparator ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net