ນີ້ແມ່ນຄໍາສັ່ງ git-fast-import ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
git-fast-import - Backend ສໍາລັບຕົວນໍາເຂົ້າຂໍ້ມູນ Git ໄວ
ສະຫຼຸບສັງລວມ
ດ້ານໜ້າ | ໄປ ການນໍາເຂົ້າໄວ [ທາງເລືອກ]
ລາຍລະອຽດ
ໂປລແກລມນີ້ມັກຈະບໍ່ແມ່ນສິ່ງທີ່ຜູ້ໃຊ້ສຸດທ້າຍຕ້ອງການດໍາເນີນການໂດຍກົງ. ຜູ້ໃຊ້ທີ່ສຸດຕ້ອງການ
ການນໍາໃຊ້ຫນຶ່ງໃນບັນດາໂຄງການ frontend ທີ່ມີຢູ່ແລ້ວ, ເຊິ່ງ parses ປະເພດສະເພາະຂອງຕ່າງປະເທດ
ແຫຼ່ງ ແລະປ້ອນເນື້ອຫາທີ່ເກັບໄວ້ຢູ່ທີ່ນັ້ນ ໄປ ການນໍາເຂົ້າໄວ.
fast-import ອ່ານຄໍາສັ່ງ / ຂໍ້ມູນປະສົມຈາກການປ້ອນມາດຕະຖານແລະຂຽນຫນຶ່ງຫຼືຫຼາຍກວ່ານັ້ນ
packfiles ໂດຍກົງເຂົ້າໄປໃນ repository ໃນປັດຈຸບັນ. ເມື່ອ EOF ໄດ້ຮັບການປ້ອນຂໍ້ມູນມາດຕະຖານ,
ການນໍາເຂົ້າໄວຂຽນອອກສາຂາທີ່ປັບປຸງແລະ tag refs, ການປັບປຸງຢ່າງເຕັມສ່ວນ repository ໃນປະຈຸບັນ
ກັບຂໍ້ມູນທີ່ນໍາເຂົ້າໃຫມ່.
backend ນໍາເຂົ້າໄວຕົວມັນເອງສາມາດນໍາເຂົ້າເຂົ້າໄປໃນ repository ເປົ່າ (ຫນຶ່ງທີ່ມີແລ້ວ
ໄດ້ເລີ່ມຕົ້ນໂດຍ ໄປ ໃນມັນ) ຫຼືເພີ່ມການປັບປຸງບ່ອນເກັບຂໍ້ມູນທີ່ມີປະຊາກອນທີ່ມີຢູ່.
ການນຳເຂົ້າເພີ່ມຂຶ້ນຫຼືບໍ່ແມ່ນໄດ້ຮັບການສະໜັບສະໜູນຈາກແຫຼ່ງຕ່າງປະເທດໂດຍສະເພາະ
ໃນໂຄງການ frontend ທີ່ໃຊ້ຢູ່.
OPTIONS
--ກຳລັງ
ບັງຄັບໃຫ້ປັບປຸງສາຂາທີ່ມີຢູ່ແລ້ວ, ເຖິງແມ່ນວ່າການເຮັດດັ່ງນັ້ນຈະເຮັດໃຫ້ຄໍາຫມັ້ນສັນຍາ
ສູນເສຍ (ຍ້ອນວ່າຄໍາຫມັ້ນສັນຍາໃຫມ່ບໍ່ມີຄໍາຫມັ້ນສັນຍາເກົ່າ).
--ງຽບ
ປິດການທໍາງານທັງຫມົດຜົນຜະລິດທີ່ບໍ່ແມ່ນການເສຍຊີວິດ, ເຮັດໃຫ້ການນໍາເຂົ້າໄວງຽບໃນເວລາທີ່ມັນສໍາເລັດຜົນ. ນີ້
ທາງເລືອກປິດການໃຊ້ງານຜົນຜະລິດສະແດງໃຫ້ເຫັນໂດຍ --stats.
--ສະຖິຕິ
ສະແດງສະຖິຕິພື້ນຖານບາງຢ່າງກ່ຽວກັບວັດຖຸທີ່ການນໍາເຂົ້າໄວໄດ້ສ້າງຕັ້ງຂື້ນ, packfiles
ພວກມັນຖືກເກັບໄວ້ໃນ, ແລະຄວາມຊົງຈໍາທີ່ໃຊ້ໂດຍການນໍາເຂົ້າໄວໃນລະຫວ່າງການດໍາເນີນການນີ້. ກຳລັງສະແດງ
ປະຈຸບັນນີ້ຜົນຜະລິດນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ, ແຕ່ສາມາດປິດການໃຊ້ງານດ້ວຍ --quiet.
ທາງເລືອກໃນການ ສໍາລັບການ ດ້ານ ໜ້າ
--cat-blob-fd=
ຂຽນຄໍາຕອບເພື່ອ get-mark, cat-blob, ແລະ ls queries ກັບ descriptor ໄຟລ໌
ແທນທີ່ຈະ stdout. ອະນຸຍາດໃຫ້ຄວາມຄືບຫນ້າຜົນຜະລິດທີ່ມີຈຸດປະສົງສໍາລັບຜູ້ໃຊ້ສຸດທ້າຍໄດ້ຖືກແຍກອອກ
ຈາກຜົນຜະລິດອື່ນໆ.
--date-format=
ລະບຸປະເພດຂອງວັນທີ frontend ຈະສະຫນອງການນໍາເຂົ້າໄວພາຍໃນຜູ້ຂຽນ,
committer ແລະ tagger ຄໍາສັ່ງ. ເບິ່ງ "ຮູບແບບວັນທີ" ຂ້າງລຸ່ມນີ້ສໍາລັບລາຍລະອຽດກ່ຽວກັບອັນໃດ
ຮູບແບບໄດ້ຮັບການສະຫນັບສະຫນູນ, ແລະ syntax ຂອງເຂົາເຈົ້າ.
--ແລ້ວໆ
ສິ້ນສຸດດ້ວຍຄວາມຜິດພາດຖ້າບໍ່ມີຄໍາສັ່ງເຮັດໃນຕອນທ້າຍຂອງການຖ່າຍທອດ. ທາງເລືອກນີ້
ອາດຈະເປັນປະໂຫຍດສໍາລັບການກວດສອບຄວາມຜິດພາດທີ່ເຮັດໃຫ້ frontend ຢຸດເຊົາກ່ອນທີ່ມັນ
ໄດ້ເລີ່ມຂຽນກະແສ.
ສະຖານທີ່ of ເຄື່ອງຫມາຍ ໄຟ
--export-marks=
ຖິ້ມຕາຕະລາງເຄື່ອງຫມາຍພາຍໃນເພື່ອ ເມື່ອສໍາເລັດ. ເຄື່ອງຫມາຍຖືກຂຽນຫນຶ່ງຕໍ່ແຖວ
ເປັນ :markid SHA-1. Frontends ສາມາດໃຊ້ໄຟລ໌ນີ້ເພື່ອກວດສອບການນໍາເຂົ້າຫຼັງຈາກພວກມັນໄດ້
ສໍາເລັດ, ຫຼືເພື່ອຊ່ວຍປະຢັດຕາຕະລາງເຄື່ອງຫມາຍໃນໄລຍະການເພີ່ມຂຶ້ນ. ເປັນ ແມ່ນພຽງແຕ່
ເປີດແລະຕັດຢູ່ໃນຈຸດກວດກາ (ຫຼືສໍາເລັດ) ເສັ້ນທາງດຽວກັນຍັງສາມາດປອດໄພ
ມອບໃຫ້ --import-marks.
--import-marks=
ກ່ອນທີ່ຈະປະມວນຜົນການປ້ອນຂໍ້ມູນໃດໆ, ໂຫຼດເຄື່ອງຫມາຍທີ່ລະບຸໄວ້ໃນ . ໄຟລ໌ປ້ອນຂໍ້ມູນຕ້ອງ
ມີຢູ່, ຈະຕ້ອງສາມາດອ່ານໄດ້, ແລະຕ້ອງໃຊ້ຮູບແບບດຽວກັນທີ່ຜະລິດໂດຍ --export-marks.
ທາງເລືອກຫຼາຍອັນອາດຈະຖືກສະໜອງໃຫ້ເພື່ອນຳເຂົ້າຫຼາຍກວ່າໜຶ່ງຊຸດເຄື່ອງໝາຍ. ຖ້າເຄື່ອງຫມາຍແມ່ນ
ກໍານົດຄ່າທີ່ແຕກຕ່າງກັນ, ໄຟລ໌ສຸດທ້າຍຊະນະ.
--import-marks-if-exists=
ເຊັ່ນດຽວກັນກັບ --import-marks ແຕ່ແທນທີ່ຈະຜິດພາດ, ຂ້າມໄຟລ໌ຢ່າງງຽບໆຖ້າມັນເຮັດ.
ບໍ່ມີຢູ່.
--[ບໍ່-]ເຄື່ອງໝາຍພີ່ນ້ອງ
ຫຼັງຈາກລະບຸ --relative-marks ເສັ້ນທາງທີ່ລະບຸດ້ວຍ --import-marks= ແລະ
--export-marks= ແມ່ນກ່ຽວຂ້ອງກັບໄດເລກະທໍລີພາຍໃນຢູ່ໃນບ່ອນເກັບຂໍ້ມູນປະຈຸບັນ. ໃນ
git-fast-import ນີ້ຫມາຍຄວາມວ່າເສັ້ນທາງແມ່ນກ່ຽວຂ້ອງກັບ .git/info/fast-import
ໄດເລກະທໍລີ. ຢ່າງໃດກໍຕາມ, ຜູ້ນໍາເຂົ້າອື່ນໆອາດຈະໃຊ້ສະຖານທີ່ທີ່ແຕກຕ່າງກັນ.
ເຄື່ອງຫມາຍທີ່ກ່ຽວຂ້ອງແລະບໍ່ແມ່ນພີ່ນ້ອງອາດຈະຖືກລວມເຂົ້າກັນໂດຍການເຊື່ອມສານ --(ບໍ່-)-relative-marks
ກັບ --(import|export)-marks= ທາງເລືອກ.
ການປະຕິບັດ ແລະ ການບີບອັດ tuning
--active-ສາຂາ=
ຈໍານວນສາຂາສູງສຸດເພື່ອຮັກສາການເຄື່ອນໄຫວໃນເວລາດຽວ. ເບິ່ງ "ການນໍາໃຊ້ຄວາມຊົງຈໍາ" ຂ້າງລຸ່ມນີ້
ສໍາລັບລາຍລະອຽດ. ຄ່າເລີ່ມຕົ້ນແມ່ນ 5.
--big-file-threshold=
ຂະຫນາດສູງສຸດຂອງ blob ທີ່ນໍາເຂົ້າໄວຈະພະຍາຍາມສ້າງ delta ສໍາລັບ, ສະແດງອອກ
ໃນ bytes. ຄ່າເລີ່ມຕົ້ນແມ່ນ 512m (512 MiB). ຜູ້ນໍາເຂົ້າບາງຄົນອາດຈະຕ້ອງການທີ່ຈະຫຼຸດລົງນີ້
ລະບົບທີ່ມີຫນ່ວຍຄວາມຈໍາຈໍາກັດ.
--ຄວາມເລິກ=
ຄວາມເລິກຂອງ delta ສູງສຸດ, ສໍາລັບ blob ແລະ deltification ຕົ້ນໄມ້. ຄ່າເລີ່ມຕົ້ນແມ່ນ 10.
--export-pack-edges=
ຫຼັງຈາກການສ້າງ packfile, ພິມເສັ້ນຂອງຂໍ້ມູນເພື່ອ ລາຍ ຊື່ ໄຟລ ໌ ຂອງ
packfile ແລະຄໍາຫມັ້ນສັນຍາສຸດທ້າຍໃນແຕ່ລະສາຂາທີ່ຖືກຂຽນໃສ່ packfile ນັ້ນ. ນີ້
ຂໍ້ມູນທີ່ອາດຈະເປັນປະໂຫຍດຫຼັງຈາກການນໍາເຂົ້າໂຄງການທີ່ຕັ້ງວັດຖຸທັງຫມົດເກີນຂອງ
4 GiB packfile ຈໍາກັດ, ເປັນຄໍາຫມັ້ນສັນຍາເຫຼົ່ານີ້ສາມາດຖືກນໍາໃຊ້ເປັນຈຸດແຂບໃນລະຫວ່າງການໂທຫາ ໄປ
pack-objects.
--max-pack-size=
ຂະໜາດສູງສຸດຂອງແຕ່ລະ packfile ຜົນຜະລິດ. ຄ່າເລີ່ມຕົ້ນແມ່ນບໍ່ຈໍາກັດ.
ຜົນປະໂຫຍດ
ການອອກແບບການນໍາເຂົ້າໄວຊ່ວຍໃຫ້ສາມາດນໍາເຂົ້າໂຄງການຂະຫນາດໃຫຍ່ໃນຈໍານວນຫນ່ວຍຄວາມຈໍາຕໍາ່ສຸດທີ່
ການນໍາໃຊ້ແລະການປຸງແຕ່ງທີ່ໃຊ້ເວລາ. ສົມມຸດວ່າ frontend ແມ່ນສາມາດເຮັດໃຫ້ທັນກັບການນໍາເຂົ້າໄວແລະ
ສະໜອງຂໍ້ມູນໃຫ້ມັນຢ່າງຕໍ່ເນື່ອງ, ເວລານຳເຂົ້າສຳລັບໂຄງການທີ່ຖືປະຫວັດ 10+ ປີ
ແລະປະກອບດ້ວຍ 100,000+ ຄໍາຫມັ້ນສັນຍາສ່ວນບຸກຄົນແມ່ນສໍາເລັດໂດຍທົ່ວໄປພຽງແຕ່ 1-2 ຊົ່ວໂມງໃນ
ຮາດແວຂ້ອນຂ້າງອ່ອນ (~$2,000 USD).
ຄໍຂວດສ່ວນໃຫຍ່ປາກົດຢູ່ໃນການເຂົ້າເຖິງຂໍ້ມູນແຫຼ່ງຕ່າງປະເທດ (ແຫຼ່ງພຽງແຕ່ບໍ່ສາມາດ
ສະກັດການແກ້ໄຂໄດ້ໄວພຽງພໍ) ຫຼືແຜ່ນ IO (ໄວການນໍາເຂົ້າຂຽນໄວເທົ່າທີ່ແຜ່ນຈະ
ເອົາຂໍ້ມູນ). ການນຳເຂົ້າຈະແລ່ນໄວຂຶ້ນຖ້າຂໍ້ມູນແຫຼ່ງຖືກເກັບໄວ້ໃນໄດຣຟ໌ອື່ນ
ກ່ວາຈຸດຫມາຍປາຍທາງ Git repository (ເນື່ອງຈາກການຂັດແຍ້ງ IO ຫນ້ອຍ).
ການພັດທະນາ COST
ດ້ານຫນ້າປົກກະຕິສໍາລັບການນໍາເຂົ້າໄວມັກຈະມີນ້ໍາຫນັກຢູ່ທີ່ປະມານ 200 ເສັ້ນ
ລະຫັດ Perl/Python/Ruby. ນັກພັດທະນາສ່ວນໃຫຍ່ສາມາດສ້າງຜູ້ນໍາເຂົ້າທີ່ເຮັດວຽກຢູ່ໃນພຽງແຕ່
ສອງສາມຊົ່ວໂມງ, ເຖິງແມ່ນວ່າມັນເປັນການເປີດເຜີຍຄັ້ງທໍາອິດຂອງພວກເຂົາກັບການນໍາເຂົ້າໄວ, ແລະບາງຄັ້ງ
ເຖິງແມ່ນວ່າກັບ Git. ນີ້ແມ່ນສະຖານະການທີ່ເຫມາະສົມ, ເນື່ອງຈາກເຄື່ອງມືການແປງສ່ວນໃຫຍ່ແມ່ນຖືກຖິ້ມ
(ໃຊ້ຄັ້ງດຽວ, ແລະບໍ່ເຄີຍເບິ່ງຄືນ).
ພາຣາກອດ OPERATION
ຄື ໄປ ການຊຸກຍູ້ or ໄປ ດຶງ, ການນໍາເຂົ້າທີ່ຈັດການໂດຍການນໍາເຂົ້າໄວແມ່ນປອດໄພທີ່ຈະດໍາເນີນການຄຽງຄູ່
ຂະຫນານ git repack -a -d ຫຼື git gc invocations, ຫຼືການດໍາເນີນງານ Git ອື່ນໆ (ລວມທັງ ໄປ
ໝາກຫຸ່ງ, ເນື່ອງຈາກວ່າວັດຖຸວ່າງແມ່ນບໍ່ເຄີຍຖືກນໍາໃຊ້ໂດຍການນໍາເຂົ້າໄວ).
fast-import ບໍ່ໄດ້ລັອກສາຂາຫຼື tag refs ມັນແມ່ນການນໍາເຂົ້າຢ່າງຈິງຈັງ. ຫຼັງຈາກ
ການນໍາເຂົ້າ, ໃນໄລຍະການປັບປຸງການອ້າງອິງຂອງຕົນ, ການທົດສອບການນໍາເຂົ້າໄວຂອງແຕ່ລະສາຂາທີ່ມີຢູ່ແລ້ວເພື່ອກວດສອບ
ການປັບປຸງຈະເປັນການປັບປຸງໄປຂ້າງຫນ້າໄວ (ຄໍາຫມັ້ນສັນຍາທີ່ເກັບຮັກສາໄວ້ໃນ ref ແມ່ນບັນຈຸຢູ່ໃນ
ປະຫວັດສາດໃຫມ່ຂອງຄໍາຫມັ້ນສັນຍາທີ່ຈະຂຽນ). ຖ້າການປັບປຸງບໍ່ແມ່ນການອັບເດດໄວ,
ການນຳເຂົ້າໄວຈະຂ້າມການອັບເດດຂໍ້ມູນນັ້ນ ແລະພິມຄຳເຕືອນແທນ. ການນໍາເຂົ້າໄວ
ສະເຫມີຈະພະຍາຍາມປັບປຸງການອ້າງອີງສາຂາທັງຫມົດ, ແລະບໍ່ຢຸດຢູ່ໃນຄວາມລົ້ມເຫຼວຄັ້ງທໍາອິດ.
ການປັບປຸງສາຂາສາມາດຖືກບັງຄັບດ້ວຍ --force, ແຕ່ແນະນໍາໃຫ້ໃຊ້ພຽງແຕ່ນີ້
ເປັນບ່ອນເກັບມ້ຽນທີ່ງຽບໆ. ການນໍາໃຊ້ --force ແມ່ນບໍ່ຈໍາເປັນສໍາລັບການນໍາເຂົ້າໃນເບື້ອງຕົ້ນ
ບ່ອນເກັບມ້ຽນຫວ່າງເປົ່າ.
ເຕັກນິກ ການສົນທະນາ
ການນໍາເຂົ້າໄວຕິດຕາມຊຸດຂອງສາຂາໃນຫນ່ວຍຄວາມຈໍາ. ສາຂາໃດສາມາດສ້າງ ຫຼື ແກ້ໄຂໄດ້ທີ່
ຈຸດໃດນຶ່ງໃນລະຫວ່າງຂະບວນການນໍາເຂົ້າໂດຍການສົ່ງຄໍາສັ່ງ commit ໃນກະແສການປ້ອນຂໍ້ມູນ. ນີ້
ການອອກແບບອະນຸຍາດໃຫ້ໂຄງການ frontend ສາມາດປະມວນຜົນໄດ້ບໍ່ຈໍາກັດຈໍານວນສາຂາ
ໃນເວລາດຽວກັນ, ການສ້າງຄໍາຫມັ້ນສັນຍາໃນຄໍາສັ່ງທີ່ເຂົາເຈົ້າມີຢູ່ຈາກຂໍ້ມູນແຫຼ່ງ.
ມັນຍັງເຮັດໃຫ້ໂປຣແກມ frontend ງ່າຍຂຶ້ນຫຼາຍ.
ການນໍາເຂົ້າໄວບໍ່ໄດ້ນໍາໃຊ້ຫຼືການແກ້ໄຂບັນຊີລາຍການທີ່ເຮັດວຽກໃນປັດຈຸບັນ, ຫຼືໄຟລ໌ໃດຫນຶ່ງຢູ່ໃນມັນ.
(ຢ່າງໃດກໍ່ຕາມມັນປັບປຸງບ່ອນເກັບມ້ຽນ Git ໃນປະຈຸບັນ, ຕາມການອ້າງອີງໂດຍ GIT_DIR.) ດັ່ງນັ້ນ
ຫນ້າທີ່ນໍາເຂົ້າອາດຈະໃຊ້ໄດເລກະທໍລີທີ່ເຮັດວຽກສໍາລັບຈຸດປະສົງຂອງຕົນເອງເຊັ່ນການສະກັດເອົາ
ເອກະສານດັດແກ້ຈາກແຫຼ່ງຕ່າງປະເທດ. ignorance ຂອງ directory ການເຮັດວຽກນີ້ຍັງ
ອະນຸຍາດໃຫ້ນໍາເຂົ້າໄວແລ່ນໄວຫຼາຍ, ຍ້ອນວ່າມັນບໍ່ຈໍາເປັນຕ້ອງດໍາເນີນການໄຟລ໌ທີ່ມີຄ່າໃຊ້ຈ່າຍໃດໆ
ປັບປຸງການດໍາເນີນງານໃນເວລາທີ່ປ່ຽນລະຫວ່າງສາຂາ.
ປັດໄຈນໍາເຂົ້າ ຮູບແບບ
ຍົກເວັ້ນຂໍ້ມູນໄຟລ໌ດິບ (ທີ່ Git ບໍ່ໄດ້ຕີຄວາມຫມາຍ) ການນໍາເຂົ້າໄວ
ຮູບແບບແມ່ນຂໍ້ຄວາມ (ASCII) ອີງໃສ່. ຮູບແບບທີ່ອີງໃສ່ຂໍ້ຄວາມນີ້ເຮັດໃຫ້ການພັດທະນາ ແລະການດີບັກງ່າຍຂຶ້ນ
ຂອງໂປລແກລມ frontend, ໂດຍສະເພາະໃນເວລາທີ່ພາສາລະດັບສູງກວ່າເຊັ່ນ Perl, Python ຫຼື Ruby
ກຳ ລັງຖືກ ນຳ ໃຊ້.
ການນໍາເຂົ້າໄວແມ່ນເຄັ່ງຄັດຫຼາຍກ່ຽວກັບການນໍາເຂົ້າຂອງມັນ. ບ່ອນທີ່ພວກເຮົາເວົ້າວ່າ SP ຂ້າງລຸ່ມນີ້ພວກເຮົາຫມາຍຄວາມວ່າ ຢ່າງແນ່ນອນ ຫນຶ່ງ
ຊ່ອງ. ເຊັ່ນດຽວກັນ LF ຫມາຍຄວາມວ່າຫນຶ່ງ (ແລະພຽງແຕ່ຫນຶ່ງ) linefeed ແລະ HT ຫນຶ່ງ (ແລະພຽງແຕ່ຫນຶ່ງ) ແນວນອນ
ແຖບ. ການສະຫນອງຕົວອັກສອນຊ່ອງຫວ່າງເພີ່ມເຕີມຈະເຮັດໃຫ້ຜົນໄດ້ຮັບທີ່ບໍ່ຄາດຄິດ, ເຊັ່ນ:
ຊື່ສາຂາຫຼືຊື່ໄຟລ໌ທີ່ມີຊ່ອງນໍາຫນ້າຫຼືຕໍ່ຫນ້າໃນຊື່ຂອງເຂົາເຈົ້າ, ຫຼືຕົ້ນ
ການຢຸດເຊົາການນໍາເຂົ້າໄວເມື່ອມັນພົບກັບການປ້ອນຂໍ້ມູນທີ່ບໍ່ຄາດຄິດ.
ນ້ໍາ ຄວາມຄິດເຫັນ
ເພື່ອຊ່ວຍໃນການດີບັ໊ກ frontends fast-import ignore any line that start with # (ASCII
pound/hash) ເຖິງແລະລວມທັງເສັ້ນສິ້ນສຸດ LF. ແຖວຄຳເຫັນອາດມີອັນໃດນຶ່ງ
ລໍາດັບຂອງ bytes ທີ່ບໍ່ມີ LF ແລະດັ່ງນັ້ນອາດຈະຖືກນໍາໃຊ້ເພື່ອປະກອບມີໃດໆ
ຂໍ້ມູນການດີບັກລະອຽດທີ່ອາດຈະສະເພາະຂອງ frontend ແລະເປັນປະໂຫຍດໃນເວລາທີ່
ກວດການ້ໍາຂໍ້ມູນການນໍາເຂົ້າໄວ.
ວັນທີ່ສະຫມັກ ຮູບແບບ
ຮູບແບບວັນທີຕໍ່ໄປນີ້ແມ່ນຮອງຮັບ. A frontend ຄວນເລືອກຮູບແບບທີ່ມັນຈະໃຊ້
ສໍາລັບການນໍາເຂົ້ານີ້ໂດຍການຖ່າຍທອດຊື່ຮູບແບບໃນ --date-format= ທາງເລືອກແຖວຄໍາສັ່ງ.
ວັດຖຸດິບ
ນີ້ແມ່ນຮູບແບບພື້ນເມືອງ Git ແລະເປັນ SP . ມັນຍັງເປັນການນໍາເຂົ້າໄວ
ຮູບແບບເລີ່ມຕົ້ນ, ຖ້າ --date-format ບໍ່ໄດ້ລະບຸ.
ເວລາຂອງເຫດການແມ່ນກໍານົດໂດຍ ເປັນຈໍານວນວິນາທີນັບຕັ້ງແຕ່ UNIX
ເວລາ (ເວລາທ່ຽງຄືນ, ວັນທີ 1 ມັງກອນ 1970, UTC) ແລະຖືກຂຽນເປັນຈຳນວນທົດສະນິຍົມ ASCII.
ການຊົດເຊີຍທ້ອງຖິ່ນແມ່ນຖືກກໍານົດໂດຍ ເປັນຄ່າຊົດເຊີຍທາງບວກ ຫຼືທາງລົບຈາກ UTC.
ຕົວຢ່າງ EST (ເຊິ່ງແມ່ນ 5 ຊົ່ວໂມງຫລັງ UTC) ຈະຖືກສະແດງອອກໃນ ໂດຍ “-0500”
ໃນຂະນະທີ່ UTC ແມ່ນ “+0000”. ການຊົດເຊີຍໃນທ້ອງຖິ່ນບໍ່ມີຜົນກະທົບ ; ມັນຖືກນໍາໃຊ້ພຽງແຕ່ເປັນ
ຄໍາແນະນໍາເພື່ອຊ່ວຍໃຫ້ການຈັດຮູບແບບປົກກະຕິສະແດງເວລາ.
ຖ້າການຊົດເຊີຍໃນທ້ອງຖິ່ນບໍ່ມີຢູ່ໃນອຸປະກອນແຫຼ່ງ, ໃຫ້ໃຊ້ "+0000", ຫຼືຫຼາຍທີ່ສຸດ
ການຊົດເຊີຍທ້ອງຖິ່ນທົ່ວໄປ. ສໍາລັບຕົວຢ່າງ, ອົງການຈັດຕັ້ງຈໍານວນຫຼາຍມີ repository CVS ທີ່ມີ
ພຽງແຕ່ເຄີຍເຂົ້າເຖິງໂດຍຜູ້ໃຊ້ທີ່ຕັ້ງຢູ່ໃນສະຖານທີ່ດຽວກັນແລະເຂດເວລາ.
ໃນກໍລະນີນີ້, ການຊົດເຊີຍທີ່ສົມເຫດສົມຜົນຈາກ UTC ສາມາດສົມມຸດໄດ້.
ບໍ່ເຫມືອນກັບຮູບແບບ rfc2822, ຮູບແບບນີ້ແມ່ນເຄັ່ງຄັດຫຼາຍ. ການປ່ຽນແປງໃດໆໃນການຈັດຮູບແບບ
ຈະເຮັດໃຫ້ການນໍາເຂົ້າຢ່າງໄວວາປະຕິເສດມູນຄ່າ.
rfc2822
ນີ້ແມ່ນຮູບແບບອີເມວມາດຕະຖານທີ່ອະທິບາຍໂດຍ RFC 2822.
ຄ່າຕົວຢ່າງແມ່ນ “Tue Feb 6 11:22:18 2007 -0500”. Git parser ແມ່ນຖືກຕ້ອງ, ແຕ່ a
ພຽງເລັກນ້ອຍໃນດ້ານ lenient ໄດ້. ມັນແມ່ນຕົວວິເຄາະດຽວກັນທີ່ໃຊ້ໂດຍ ໄປ am ໃນເວລາທີ່ການນໍາໃຊ້ການແກ້ໄຂ
ໄດ້ຮັບຈາກອີເມລ໌.
ບາງສະຕຣິງທີ່ບໍ່ຖືກຕ້ອງອາດຈະຖືກຍອມຮັບເປັນວັນທີທີ່ຖືກຕ້ອງ. ໃນບາງກໍລະນີເຫຼົ່ານີ້ Git ຈະ
ຍັງສາມາດໄດ້ຮັບວັນທີທີ່ຖືກຕ້ອງຈາກສະຕຣິງທີ່ບໍ່ຖືກຕ້ອງ. ຍັງມີ
ບາງປະເພດຂອງສະຕຣິງທີ່ບໍ່ຖືກຕ້ອງທີ່ Git ຈະວິເຄາະຜິດ, ແລະຍັງຖືວ່າຖືກຕ້ອງ.
ສະຕຣິງທີ່ມີຮູບແບບບໍ່ຖືກຕ້ອງຢ່າງຈິງຈັງຈະຖືກປະຕິເສດ.
ບໍ່ຄືກັບຮູບແບບດິບຂ້າງເທິງ, ເຂດເວລາ/UTC ຂໍ້ມູນຊົດເຊີຍທີ່ມີຢູ່ໃນ RFC
ສະຕຣິງວັນທີ 2822 ຖືກນໍາໃຊ້ເພື່ອປັບຄ່າວັນທີເປັນ UTC ກ່ອນທີ່ຈະເກັບຮັກສາ. ເພາະສະນັ້ນ
ມັນເປັນສິ່ງສໍາຄັນທີ່ຂໍ້ມູນນີ້ຖືກຕ້ອງເທົ່າທີ່ເປັນໄປໄດ້.
ຖ້າອຸປະກອນແຫຼ່ງໃຊ້ RFC 2822 style dates, frontend ຄວນປ່ອຍໃຫ້ນໍາເຂົ້າໄວ
ຈັດການການວິເຄາະແລະການແປງ (ແທນທີ່ຈະພະຍາຍາມເຮັດມັນເອງ) ເປັນ Git
parser ໄດ້ຮັບການທົດສອບທີ່ດີໃນທໍາມະຊາດ.
Frontends ຄວນມັກຮູບແບບດິບຖ້າອຸປະກອນແຫຼ່ງໃຊ້ UNIX-epoch ແລ້ວ
ຮູບແບບ, ສາມາດ coaxed ເພື່ອໃຫ້ວັນທີໃນຮູບແບບນັ້ນ, ຫຼືຮູບແບບຂອງມັນແມ່ນງ່າຍດາຍ
ປ່ຽນແປງໄດ້, ເພາະວ່າບໍ່ມີຄວາມຊັດເຈນໃນການວິເຄາະ.
ໃນປັດຈຸບັນ
ໃຊ້ເວລາ ແລະເຂດເວລາປັດຈຸບັນສະເໝີ. ໃນປັດຈຸບັນຕົວຫນັງສືຕ້ອງໄດ້ຮັບການສະຫນອງໃຫ້ສະເຫມີ
.
ນີ້ແມ່ນຮູບແບບຂອງຫຼິ້ນ. ເຂດເວລາ ແລະເວລາຂອງລະບົບນີ້ຖືກສຳເນົາຢູ່ສະເໝີ
ເຂົ້າໄປໃນສະຕຣິງຕົວຕົນໃນເວລາທີ່ມັນຖືກສ້າງຂື້ນໂດຍການນໍາເຂົ້າໄວ. ບໍ່ມີ
ວິທີການກໍານົດເວລາຫຼືເຂດເວລາທີ່ແຕກຕ່າງກັນ.
ຮູບແບບສະເພາະນີ້ແມ່ນສະໜອງໃຫ້ເນື່ອງຈາກມັນສັ້ນໃນການປະຕິບັດ ແລະອາດຈະເປັນປະໂຫຍດຕໍ່ a
ຂະບວນການທີ່ຕ້ອງການສ້າງຄໍາຫມັ້ນສັນຍາໃຫມ່ໃນປັດຈຸບັນ, ໂດຍບໍ່ຈໍາເປັນຕ້ອງໃຊ້ການເຮັດວຽກ
ໄດເລກະທໍລີຫຼື ໄປ update-index.
ຖ້າຄຳສັ່ງຂອງຜູ້ຂຽນ ແລະ committer ແຍກກັນຖືກໃຊ້ໃນ commit, timestamps ອາດຈະບໍ່ໄດ້
ກົງກັນ, ເພາະວ່າໂມງລະບົບຈະຖືກ polled ສອງຄັ້ງ (ຫນຶ່ງຄັ້ງສໍາລັບແຕ່ລະຄໍາສັ່ງ). ວິທີດຽວ
ເພື່ອຮັບປະກັນວ່າຂໍ້ມູນຕົວຕົນຂອງຜູ້ຂຽນ ແລະ committer ມີເວລາດຽວກັນ
ແມ່ນເພື່ອຍົກເລີກຜູ້ຂຽນ (ດັ່ງນັ້ນການຄັດລອກຈາກ committer) ຫຼືໃຊ້ຮູບແບບວັນທີອື່ນທີ່ບໍ່ແມ່ນ
ໃນປັດຈຸບັນ.
ຄໍາສັ່ງ
fast-import ຍອມຮັບຄໍາສັ່ງຈໍານວນຫນຶ່ງເພື່ອປັບປຸງ repository ໃນປັດຈຸບັນແລະຄວບຄຸມ
ຂະບວນການນໍາເຂົ້າໃນປະຈຸບັນ. ການສົນທະນາລາຍລະອຽດເພີ່ມເຕີມ (ມີຕົວຢ່າງ) ຂອງແຕ່ລະຄໍາສັ່ງຕໍ່ໄປນີ້
ຕໍ່ມາ.
ຄໍາຫມັ້ນສັນຍາ
ສ້າງສາຂາໃຫມ່ຫຼືປັບປຸງສາຂາທີ່ມີຢູ່ແລ້ວໂດຍການສ້າງຄໍາຫມັ້ນສັນຍາໃຫມ່ແລະ
ການປັບປຸງສາຂາເພື່ອຊີ້ໃຫ້ເຫັນຄໍາຫມັ້ນສັນຍາທີ່ສ້າງຂຶ້ນໃຫມ່.
ໂຄດຄໍາສັ່ງ
ສ້າງວັດຖຸແທັກທີ່ລະບຸໄວ້ຈາກ commit ຫຼືສາຂາທີ່ມີຢູ່ແລ້ວ. ແທັກນ້ຳໜັກເບົາ
ຄຳສັ່ງນີ້ບໍ່ຖືກຮອງຮັບ, ເພາະວ່າພວກມັນບໍ່ຖືກແນະນຳໃຫ້ບັນທຶກ
ຈຸດທີ່ມີຄວາມຫມາຍໃນເວລາ.
reset
ຣີເຊັດສາຂາທີ່ມີຢູ່ແລ້ວ (ຫຼືສາຂາໃໝ່) ເປັນການແກ້ໄຂສະເພາະ. ຄໍາສັ່ງນີ້ຕ້ອງ
ຖືກນໍາໃຊ້ເພື່ອປ່ຽນສາຂາໄປຫາການແກ້ໄຂສະເພາະໂດຍບໍ່ມີການເຮັດຄໍາຫມັ້ນສັນຍາກ່ຽວກັບມັນ.
blobs
ປ່ຽນຂໍ້ມູນໄຟລ໌ດິບເປັນ blob, ສໍາລັບການນໍາໃຊ້ໃນອະນາຄົດໃນຄໍາສັ່ງ commit. ຄໍາສັ່ງນີ້ແມ່ນ
ທາງເລືອກແລະບໍ່ຈໍາເປັນເພື່ອດໍາເນີນການນໍາເຂົ້າ.
ດ່ານ
ບັງຄັບໃຫ້ນໍາເຂົ້າໄວເພື່ອປິດແພັກໄຟລ໌ປັດຈຸບັນ, ສ້າງເຊັກຊັມ SHA-1 ທີ່ເປັນເອກະລັກຂອງມັນ
ແລະດັດສະນີ, ແລະເລີ່ມຕົ້ນ packfile ໃຫມ່. ຄໍາສັ່ງນີ້ແມ່ນທາງເລືອກແລະບໍ່ຈໍາເປັນຕ້ອງ
ປະຕິບັດການນໍາເຂົ້າ.
ຄວາມຄືບຫນ້າ
ເຮັດໃຫ້ການນໍາເຂົ້າໄວ echo ເສັ້ນທັງຫມົດໄປສູ່ຜົນຜະລິດມາດຕະຖານຂອງຕົນເອງ. ຄໍາສັ່ງນີ້ແມ່ນ
ທາງເລືອກແລະບໍ່ຈໍາເປັນເພື່ອດໍາເນີນການນໍາເຂົ້າ.
ເຮັດ
ໝາຍຈຸດສິ້ນສຸດຂອງກະແສ. ຄໍາສັ່ງນີ້ແມ່ນທາງເລືອກເວັ້ນເສຍແຕ່ວ່າຄຸນສົມບັດທີ່ເຮັດແລ້ວແມ່ນ
ຮ້ອງຂໍໂດຍໃຊ້ຕົວເລືອກເສັ້ນຄໍາສັ່ງ --done ຫຼືຄຸນສົມບັດຄໍາສັ່ງສໍາເລັດ.
ຮັບເຄື່ອງໝາຍ
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມ SHA-1 ທີ່ສອດຄ້ອງກັນກັບເຄື່ອງຫມາຍໄປຫາຕົວອະທິບາຍໄຟລ໌
ຕັ້ງດ້ວຍ --cat-blob-fd, ຫຼື stdout ຖ້າບໍ່ໄດ້ລະບຸ.
cat-blob
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມ blob ໃນ cat-file --ຊຸດ ຮູບແບບການອະທິບາຍໄຟລ໌
ຕັ້ງດ້ວຍ --cat-blob-fd ຫຼື stdout ຖ້າບໍ່ໄດ້ລະບຸ.
ls
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມເສັ້ນທີ່ອະທິບາຍລາຍຊື່ໄດເລກະທໍລີໃນ ls-ຕົ້ນໄມ້ ຮູບແບບເປັນ
ຕົວອະທິບາຍໄຟລ໌ທີ່ຕັ້ງດ້ວຍ --cat-blob-fd ຫຼື stdout ຖ້າບໍ່ໄດ້ລະບຸ.
ຄຸນນະສົມບັດ
ເປີດໃຊ້ຄຸນສົມບັດທີ່ລະບຸໄວ້. ນີ້ຮຽກຮ້ອງໃຫ້ມີການນໍາເຂົ້າໄວສະຫນັບສະຫນູນທີ່ກໍານົດໄວ້
ຄຸນນະສົມບັດ, ແລະ aborts ຖ້າຫາກວ່າມັນບໍ່ໄດ້.
ທາງເລືອກ
ລະບຸຕົວເລືອກໃດນຶ່ງທີ່ລະບຸໄວ້ໃນ OPTIONS ທີ່ບໍ່ປ່ຽນແປງສະຕຣີມມິນິຕິກເປັນ
ເຫມາະສົມກັບຄວາມຕ້ອງການຂອງ frontend. ຄໍາສັ່ງນີ້ແມ່ນທາງເລືອກແລະບໍ່ຈໍາເປັນເພື່ອດໍາເນີນການ
ນໍາເຂົ້າ.
ຄໍາຫມັ້ນສັນຍາ
ສ້າງຫຼືປັບປຸງສາຂາທີ່ມີຄໍາຫມັ້ນສັນຍາໃຫມ່, ບັນທຶກການປ່ຽນແປງຢ່າງມີເຫດຜົນຕໍ່ໂຄງການ.
'ຄໍາຫມັ້ນສັນຍາ' SP LF
ເຄື່ອງໝາຍ?
('ຜູ້ຂຽນ' (SP )? SP LT GT SP LF)?
'ຜູ້ຮັບຜິດຊອບ' (SP )? SP LT GT SP LF
ຂໍ້ມູນ
('ຈາກ' SP LF)?
('ຮວມ' SP LF)?
(filemodify | filedelete | filecopy | filerename | filedeleteall | notemodify)*
LF?
ຢູ່ໃສ ແມ່ນຊື່ຂອງສາຂາເພື່ອເຮັດໃຫ້ຄໍາຫມັ້ນສັນຍາ. ໂດຍທົ່ວໄປແລ້ວຊື່ສາຂາແມ່ນ
ຄຳນຳໜ້າດ້ວຍ refs/heads/ ໃນ Git, ສະນັ້ນ ການນຳເຂົ້າ CVS ສັນຍາລັກສາຂາ RELENG-1_0 ຈະໃຊ້
refs/heads/RELENG-1_0 ສໍາລັບຄ່າຂອງ . ມູນຄ່າຂອງ ຕ້ອງເປັນຊື່ປ່ຽນທີ່ຖືກຕ້ອງ
ໃນ Git. ເນື່ອງຈາກ LF ບໍ່ຖືກຕ້ອງໃນ Git refname, ບໍ່ມີການອ້າງອິງຫຼື syntax ຫນີຖືກສະຫນັບສະຫນູນ.
ທີ່ນີ້.
ຄໍາສັ່ງເຄື່ອງຫມາຍເປັນທາງເລືອກທີ່ອາດຈະປາກົດຂຶ້ນ, ຮ້ອງຂໍການນໍາເຂົ້າໄວເພື່ອຊ່ວຍປະຢັດກະສານອ້າງອີງ
ຄໍາຫມັ້ນສັນຍາທີ່ສ້າງຂຶ້ນໃຫມ່ສໍາລັບການນໍາໃຊ້ໃນອະນາຄົດໂດຍ frontend (ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບຮູບແບບ). ມັນແມ່ນຫຼາຍ
ທົ່ວໄປສໍາລັບ frontends ເພື່ອຫມາຍທຸກຄໍາຫມັ້ນສັນຍາທີ່ເຂົາເຈົ້າສ້າງ, ດັ່ງນັ້ນອະນຸຍາດໃຫ້ສາຂາໃນອະນາຄົດ
ການສ້າງຈາກຄໍາຫມັ້ນສັນຍານໍາເຂົ້າໃດໆ.
ຄໍາສັ່ງຂໍ້ມູນຕໍ່ໄປນີ້ committer ຈະຕ້ອງສະຫນອງຂໍ້ຄວາມ commit (ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບຂໍ້ມູນ
syntax ຄໍາສັ່ງ). ເພື່ອນໍາເຂົ້າຂໍ້ຄວາມ commit ຫວ່າງເປົ່າໃຫ້ໃຊ້ຂໍ້ມູນຄວາມຍາວ 0. ສົ່ງຂໍ້ຄວາມ
ແມ່ນຮູບແບບຟຣີແລະບໍ່ໄດ້ຖືກຕີຄວາມຫມາຍໂດຍ Git. ໃນປັດຈຸບັນພວກເຂົາຕ້ອງໄດ້ຮັບການເຂົ້າລະຫັດໃນ UTF-8, ເປັນ
fast-import ບໍ່ອະນຸຍາດໃຫ້ມີການລະບຸການເຂົ້າລະຫັດອື່ນ.
ສູນ ຫຼືຫຼາຍກວ່ານັ້ນແກ້ໄຂໄຟລ໌, ລຶບໄຟລ໌, ສຳເນົາໄຟລ໌, ຊື່ໄຟລ໌, ລຶບໄຟລ໌ ແລະບັນທຶກແກ້ໄຂ
ຄໍາສັ່ງອາດຈະຖືກລວມເຂົ້າໃນການປັບປຸງເນື້ອໃນຂອງສາຂາກ່ອນທີ່ຈະສ້າງ
ຄໍາຫມັ້ນສັນຍາ. ຄໍາສັ່ງເຫຼົ່ານີ້ອາດຈະຖືກສະຫນອງໃນຄໍາສັ່ງໃດໆ. ຢ່າງໃດກໍຕາມ, ມັນແນະນໍາໃຫ້ a
ຄໍາສັ່ງ filedeleteall ກ່ອນຄໍາສັ່ງ filemodify, filecopy, filerename ແລະ notemodify ທັງຫມົດ
ໃນຄໍາຫມັ້ນສັນຍາດຽວກັນ, ເປັນ filedeleteall ເຊັດສາຂາສະອາດ (ເບິ່ງຂ້າງລຸ່ມນີ້).
LF ຫຼັງຈາກຄໍາສັ່ງແມ່ນທາງເລືອກ (ມັນເຄີຍຕ້ອງການ).
ຜູ້ປະພັນ
ຄໍາສັ່ງຂອງຜູ້ຂຽນອາດຈະປາກົດເປັນທາງເລືອກ, ຖ້າຂໍ້ມູນຜູ້ຂຽນອາດຈະແຕກຕ່າງຈາກ
ຂໍ້ມູນຂອງຄະນະກໍາມະການ. ຖ້າຜູ້ຂຽນຖືກລະເວັ້ນ, ການນໍາເຂົ້າໄວຈະອັດຕະໂນມັດ
ໃຊ້ຂໍ້ມູນຂອງຄະນະກໍາມະການສໍາລັບສ່ວນຜູ້ຂຽນຂອງຄໍາຫມັ້ນສັນຍາ. ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບ a
ລາຍລະອຽດຂອງພາກສະຫນາມໃນຜູ້ຂຽນ, ຍ້ອນວ່າພວກເຂົາແມ່ນຄ້າຍຄືກັນກັບ committer.
ຜູ້ເດີນທາງ
ຄໍາສັ່ງ committer ຊີ້ບອກຜູ້ທີ່ເຮັດຄໍາຫມັ້ນສັນຍານີ້, ແລະໃນເວລາທີ່ເຂົາເຈົ້າເຮັດມັນ.
ທີ່ນີ້ ແມ່ນຊື່ສະແດງຂອງບຸກຄົນ (ຕົວຢ່າງ “Com M Itter”) ແລະ ແມ່ນ
ທີ່ຢູ່ອີເມວຂອງບຸກຄົນ (“[email protected]”). LT ແລະ GT ແມ່ນຕົວໜັງສືທີ່ນ້ອຍກວ່າ
ສັນຍາລັກ (\x3c) ແລະໃຫຍ່ກວ່າ (\x3e). ເຫຼົ່ານີ້ແມ່ນຕ້ອງການເພື່ອ delimit ອີເມວ
ທີ່ຢູ່ຈາກຊ່ອງຂໍ້ມູນອື່ນໆໃນແຖວ. ໃຫ້ສັງເກດວ່າ ແລະ ມີຮູບແບບຟຣີ
ແລະອາດຈະປະກອບດ້ວຍລໍາດັບຂອງ bytes, ຍົກເວັ້ນ LT, GT ແລະ LF. ໂດຍປົກກະຕິແມ່ນ UTF-8
ເຂົ້າລະຫັດ.
ເວລາຂອງການປ່ຽນແປງແມ່ນກໍານົດໂດຍ ໂດຍໃຊ້ຮູບແບບວັນທີທີ່ເລືອກ
ໂດຍ --date-format= ທາງເລືອກແຖວຄໍາສັ່ງ. ເບິ່ງ "ຮູບແບບວັນທີ" ຂ້າງເທິງສໍາລັບຊຸດ
ຂອງຮູບແບບສະຫນັບສະຫນູນ, ແລະ syntax ຂອງເຂົາເຈົ້າ.
ຈາກ
ຄໍາສັ່ງຈາກແມ່ນໃຊ້ເພື່ອກໍານົດຄໍາຫມັ້ນສັນຍາທີ່ຈະເລີ່ມຕົ້ນສາຂານີ້ຈາກ. ນີ້
ການແກ້ໄຂຈະເປັນບັນພະບຸລຸດທໍາອິດຂອງຄໍາຫມັ້ນສັນຍາໃຫມ່. ສະພາບຂອງຕົ້ນໄມ້ທີ່ສ້າງຂຶ້ນໃນ
ຄໍາຫມັ້ນສັນຍານີ້ຈະເລີ່ມຕົ້ນກັບລັດທີ່ຈາກຄໍາຫມັ້ນສັນຍາ, ແລະໄດ້ຮັບການປ່ຽນແປງໂດຍການ
ການດັດແກ້ເນື້ອໃນຄໍາຫມັ້ນສັນຍານີ້.
ການລະເວັ້ນຈາກຄໍາສັ່ງໃນຄໍາຫມັ້ນສັນຍາທໍາອິດຂອງສາຂາໃຫມ່ຈະເຮັດໃຫ້ການນໍາເຂົ້າໄວ
ເພື່ອສ້າງຄໍາຫມັ້ນສັນຍາທີ່ບໍ່ມີບັນພະບຸລຸດ. ນີ້ມັກຈະຕ້ອງການພຽງແຕ່ສໍາລັບເບື້ອງຕົ້ນ
ຄໍາຫມັ້ນສັນຍາຂອງໂຄງການ. ຖ້າ frontend ສ້າງໄຟລ໌ທັງຫມົດຈາກ scratch ໃນເວລາທີ່ເຮັດໃຫມ່
ສາຂາ, ຄໍາສັ່ງ merge ອາດຈະຖືກນໍາໃຊ້ແທນທີ່ຈະມາຈາກເພື່ອເລີ່ມຕົ້ນຄໍາຫມັ້ນສັນຍາກັບຫວ່າງເປົ່າ
ຕົ້ນໄມ້. Omitting ຈາກຄໍາສັ່ງກ່ຽວກັບສາຂາທີ່ມີຢູ່ແລ້ວມັກຈະຕ້ອງການ, ເປັນ
ຄໍາ ຫມັ້ນ ສັນ ຍາ ໃນ ປະ ຈຸ ບັນ ກ່ຽວ ກັບ ສາ ຂາ ທີ່ ອັດ ຕະ ໂນ ມັດ ຄາດ ວ່າ ຈະ ເປັນ ບັນ ພະ ບຸ ລຸດ ທໍາ ອິດ ຂອງ
ຄໍາຫມັ້ນສັນຍາໃຫມ່.
ເນື່ອງຈາກ LF ບໍ່ຖືກຕ້ອງໃນ Git refname ຫຼື SHA-1 expression, ບໍ່ມີການອ້າງອີງ ຫຼື escaping syntax
ສະຫນັບສະຫນູນພາຍໃນ .
ທີ່ນີ້ ແມ່ນອັນໃດນຶ່ງຕໍ່ໄປນີ້:
· ຊື່ຂອງສາຂາທີ່ມີຢູ່ແລ້ວໃນຕາຕະລາງສາຂາພາຍໃນຂອງ fast-import. ຖ້າ
fast-import ບໍ່ຮູ້ຊື່, ມັນຖືວ່າເປັນ SHA-1 expression.
· ເອກະສານອ້າງອີງ,: , ຢູ່ໃສ ແມ່ນຫມາຍເລກ.
ເຫດຜົນການນໍາເຂົ້າໄວການນໍາໃຊ້: ເພື່ອລະບຸການອ້າງອີງເຄື່ອງຫມາຍແມ່ນຕົວອັກສອນນີ້ບໍ່ແມ່ນ
ທາງດ້ານກົດໝາຍໃນຊື່ສາຂາ Git. ຊັ້ນນໍາ : ເຮັດໃຫ້ມັນງ່າຍທີ່ຈະຈໍາແນກລະຫວ່າງ
ເຄື່ອງໝາຍ 42 (:42) ແລະສາຂາ 42 (42 ຫຼື refs/heads/42), ຫຼືຫຍໍ້ມາຈາກ SHA-1.
ເຊິ່ງເກີດຂຶ້ນກັບຕົວເລກພື້ນຖານ 10 ຕົວເລກເທົ່ານັ້ນ.
ເຄື່ອງໝາຍຕ້ອງຖືກປະກາດ (ຜ່ານເຄື່ອງໝາຍ) ກ່ອນທີ່ຈະສາມາດນຳໃຊ້ໄດ້.
· commit SHA-40 ເຕັມ 1 byte ຫຼືຫຍໍ້ມາຈາກ hex.
· ທຸກໆການສະແດງອອກ Git SHA-1 ທີ່ຖືກຕ້ອງທີ່ແກ້ໄຂກັບຄໍາຫມັ້ນສັນຍາ. ເບິ່ງ “ການລະບຸ
ການທົບທວນຄືນ” ໃນ ການວິໄສທັດ(7) ສໍາລັບລາຍລະອຽດ.
· null ພິເສດ SHA-1 (40 zeros) ກໍານົດວ່າສາຂາຈະຖືກໂຍກຍ້າຍ.
ກໍລະນີພິເສດຂອງການເລີ່ມຕົ້ນການນໍາເຂົ້າເພີ່ມຂຶ້ນຈາກມູນຄ່າສາຂາໃນປະຈຸບັນ
ຄວນຂຽນເປັນ:
ຈາກ refs/heads/ສາຂາ^0
ຄໍາຕໍ່ທ້າຍ ^0 ແມ່ນມີຄວາມຈໍາເປັນເນື່ອງຈາກການນໍາເຂົ້າໄວບໍ່ອະນຸຍາດໃຫ້ສາຂາເລີ່ມຕົ້ນຈາກ
ຕົວຂອງມັນເອງ, ແລະສາຂາໄດ້ຖືກສ້າງຂື້ນໃນຄວາມຊົງຈໍາກ່ອນທີ່ຄໍາສັ່ງຈາກຈະຖືກອ່ານຈາກ
ວັດສະດຸປ້ອນ. ການເພີ່ມ ^0 ຈະບັງຄັບໃຫ້ນໍາເຂົ້າໄວເພື່ອແກ້ໄຂຄໍາຫມັ້ນສັນຍາຜ່ານ Git's
ຫໍສະໝຸດການວິເຄາະການດັດແກ້, ແທນທີ່ຈະເປັນຕາຕະລາງສາຂາພາຍໃນຂອງມັນ, ດັ່ງນັ້ນການໂຫຼດໃນ
ມູນຄ່າທີ່ມີຢູ່ແລ້ວຂອງສາຂາ.
ລວມ
ລວມມີໜຶ່ງຄຳໝັ້ນສັນຍາບັນພະບຸລຸດເພີ່ມເຕີມ. ການເຊື່ອມຕໍ່ເຊື້ອສາຍເພີ່ມເຕີມບໍ່ປ່ຽນແປງ
ວິທີການສ້າງລັດຕົ້ນໄມ້ຢູ່ໃນຄໍາຫມັ້ນສັນຍານີ້. ຖ້າຄໍາສັ່ງຈາກຖືກລະເວັ້ນເມື່ອໃດ
ການສ້າງສາຂາໃຫມ່, ຄໍາຫມັ້ນສັນຍາການລວມຄັ້ງທໍາອິດຈະເປັນບັນພະບຸລຸດຄັ້ງທໍາອິດຂອງ
commit ໃນປັດຈຸບັນ, ແລະສາຂາຈະເລີ່ມຕົ້ນອອກໂດຍບໍ່ມີໄຟລ໌. ຈໍານວນບໍ່ຈໍາກັດຂອງ
merge ຄໍາສັ່ງຕໍ່ຄໍາຫມັ້ນສັນຍາແມ່ນໄດ້ຮັບອະນຸຍາດໂດຍການນໍາເຂົ້າໄວ, ສະນັ້ນການສ້າງຕັ້ງທາງການ n
ໄປ.
ທີ່ນີ້ ແມ່ນຄໍາຫມັ້ນສັນຍາການສະແດງອອກໃດໆທີ່ຍອມຮັບໂດຍຈາກ
(ເບິ່ງຢູ່ຂ້າງເທິງ).
ແກ້ໄຂໄຟລ໌
ຮວມຢູ່ໃນຄໍາສັ່ງທີ່ຈະເພີ່ມໄຟລ໌ໃໝ່ ຫຼືປ່ຽນເນື້ອຫາທີ່ມີຢູ່ແລ້ວ
ໄຟລ໌. ຄໍາສັ່ງນີ້ມີສອງວິທີທີ່ແຕກຕ່າງກັນໃນການກໍານົດເນື້ອໃນຂອງໄຟລ໌.
ຮູບແບບຂໍ້ມູນພາຍນອກ
ເນື້ອໃນຂໍ້ມູນຂອງໄຟລ໌ໄດ້ຖືກສະໜອງໃຫ້ໂດຍຄໍາສັ່ງ blob ກ່ອນ. ໄດ້
frontend ພຽງແຕ່ຕ້ອງການເຊື່ອມຕໍ່ມັນ.
'M' SP SP SP LF
ທີ່ນີ້ປົກກະຕິແລ້ວ ຕ້ອງເປັນການອ້າງອີງເຄື່ອງໝາຍ (: ) ກໍານົດໂດຍກ່ອນ
ຄໍາສັ່ງ blob, ຫຼື SHA-40 ເຕັມ 1-byte ຂອງວັດຖຸ Git blob ທີ່ມີຢູ່ແລ້ວ. ຖ້າ ແມ່ນ
040000` ແລ້ວ ຕ້ອງເປັນ SHA-40 ເຕັມ 1-byte ຂອງຕົ້ນໄມ້ Git ທີ່ມີຢູ່ແລ້ວ
ວັດຖຸ ຫຼືເຄື່ອງໝາຍອ້າງອີງທີ່ຕັ້ງດ້ວຍ --import-marks.
ຮູບແບບຂໍ້ມູນໃນແຖວ
ເນື້ອໃນຂໍ້ມູນຂອງໄຟລ໌ຍັງບໍ່ທັນໄດ້ສະໜອງໃຫ້ເທື່ອ. Frontend ຕ້ອງການ
ສະຫນອງມັນເປັນສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງດັດແກ້ນີ້.
'M' SP SP 'inline' SP LF
ຂໍ້ມູນ
ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບລາຍລະອຽດຂອງຄໍາສັ່ງຂໍ້ມູນ.
ໃນທັງສອງຮູບແບບ ແມ່ນປະເພດຂອງການປ້ອນໄຟລ໌, ລະບຸໄວ້ໃນ octal. Git ເທົ່ານັ້ນ
ສະຫນັບສະຫນູນຮູບແບບດັ່ງຕໍ່ໄປນີ້:
· 100644 ຫຼື 644: ໄຟລ໌ປົກກະຕິ (ບໍ່ສາມາດປະຕິບັດໄດ້). ສ່ວນໃຫຍ່ຂອງໄຟລ໌ໃນຫຼາຍທີ່ສຸດ
ໂຄງການນໍາໃຊ້ຮູບແບບນີ້. ຖ້າສົງໃສ, ນີ້ແມ່ນສິ່ງທີ່ທ່ານຕ້ອງການ.
· 100755 ຫຼື 755: ໄຟລ໌ປົກກະຕິ, ແຕ່ສາມາດປະຕິບັດໄດ້.
· 120000: A symlink, ເນື້ອໃນຂອງໄຟລ໌ຈະເປັນເປົ້າຫມາຍການເຊື່ອມຕໍ່.
· 160000: gitlink, SHA-1 ຂອງວັດຖຸຫມາຍເຖິງຄໍາຫມັ້ນສັນຍາຢູ່ໃນບ່ອນເກັບມ້ຽນອື່ນ.
ການເຊື່ອມຕໍ່ Git ສາມາດຖືກກໍານົດໂດຍ SHA ຫຼືຜ່ານເຄື່ອງຫມາຍຄໍາຫມັ້ນສັນຍາເທົ່ານັ້ນ. ພວກເຂົາເຈົ້າໄດ້ຖືກນໍາໃຊ້ເພື່ອ
ປະຕິບັດ submodules.
· 040000: A subdirectory. ໄດເລກະທໍລີຍ່ອຍສາມາດຖືກກໍານົດໂດຍ SHA ຫຼືຜ່ານ a
ເຄື່ອງໝາຍຕົ້ນໄມ້ຖືກຕັ້ງດ້ວຍ --import-marks.
ໃນທັງສອງຮູບແບບ ແມ່ນເສັ້ນທາງທີ່ສົມບູນຂອງໄຟລ໌ທີ່ຈະເພີ່ມ (ຖ້າບໍ່ແມ່ນແລ້ວ
ທີ່ມີຢູ່ແລ້ວ) ຫຼືດັດແກ້ (ຖ້າມີຢູ່ແລ້ວ).
ກ string ຈະຕ້ອງໃຊ້ຕົວແຍກໄດເລກະທໍລີແບບ UNIX (forward slash /), ອາດຈະ
ມີໄບຕ໌ໃດນຶ່ງນອກເໜືອໄປຈາກ LF, ແລະຈະຕ້ອງບໍ່ເລີ່ມຕົ້ນດ້ວຍວົງຢືມຄູ່ (").
ເສັ້ນທາງສາມາດໃຊ້ການອ້າງອີງສະຕຣິງແບບ C; ນີ້ແມ່ນຍອມຮັບໃນທຸກກໍລະນີແລະບັງຄັບຖ້າ
ຊື່ໄຟລ໌ເລີ່ມຕົ້ນດ້ວຍວົງຢືມສອງເທົ່າ ຫຼືມີ LF. ໃນການອ້າງອີງແບບ C, ສົມບູນ
ຊື່ຄວນຈະຖືກອ້ອມຮອບດ້ວຍວົງຢືມຄູ່, ແລະ LF, backslash, ຫຼືວົງຢືມຄູ່
ຕົວອັກສອນຕ້ອງຖືກຫລົບໜີໂດຍການນຳໜ້າພວກມັນດ້ວຍ backslash (ເຊັ່ນ, "path/with\n, \\
ແລະ \" ໃນມັນ").
ມູນຄ່າຂອງ ຕ້ອງຢູ່ໃນຮູບແບບ canonical. ນັ້ນແມ່ນມັນບໍ່ຄວນ:
· ມີອົງປະກອບໄດເລກະທໍລີຫວ່າງເປົ່າ (ເຊັ່ນ: foo//bar ບໍ່ຖືກຕ້ອງ),
· ສິ້ນສຸດດ້ວຍຕົວຂັ້ນໄດເລກະທໍລີ (ເຊັ່ນ: foo/ ບໍ່ຖືກຕ້ອງ),
· ເລີ່ມຕົ້ນດ້ວຍຕົວຂັ້ນໄດເລກະທໍລີ (ຕົວຢ່າງ /foo ບໍ່ຖືກຕ້ອງ),
·ປະກອບດ້ວຍອົງປະກອບພິເສດ. ຫຼື .. (ເຊັ່ນ foo/./bar ແລະ foo/../bar ແມ່ນ
ບໍ່ຖືກຕ້ອງ).
ຮາກຂອງຕົ້ນໄມ້ສາມາດໄດ້ຮັບການສະແດງໂດຍສາຍເປົ່າເປັນ .
ມັນໄດ້ຖືກແນະນໍາວ່າ ສະເຫມີຖືກເຂົ້າລະຫັດໂດຍໃຊ້ UTF-8.
ລຶບໄຟລ໌
ຮວມຢູ່ໃນຄໍາສັ່ງທີ່ຈະລຶບໄຟລ໌ອອກ ຫຼືລຶບທັງໝົດຄືນຊ້ຳໆ
ໄດເລກະທໍລີຈາກສາຂາ. ຖ້າການໂຍກຍ້າຍໄຟລ໌ຫຼືໄດເລກະທໍລີເຮັດໃຫ້ໄດເລກະທໍລີແມ່ຂອງມັນ
ຫວ່າງເປົ່າ, ໄດເຣັກທໍຣີຫຼັກຈະຖືກລຶບອອກໂດຍອັດຕະໂນມັດເຊັ່ນກັນ. ນີ້ cascades ເຖິງ
ຕົ້ນໄມ້ຈົນກ່ວາໄດເລກະທໍລີທີ່ບໍ່ຫວ່າງເປົ່າທໍາອິດຫຼືຮາກຈະມາຮອດ.
'D' SP LF
ທີ່ນີ້ ແມ່ນເສັ້ນທາງທີ່ສົມບູນຂອງໄຟລ໌ຫຼືໄດເລກະທໍລີຍ່ອຍທີ່ຈະຖືກລຶບອອກຈາກ
ສາຂາ. ເບິ່ງ filemodify ຂ້າງເທິງສໍາລັບລາຍລະອຽດລາຍລະອຽດຂອງ .
ສຳເນົາເອກະສານ
Recursively ສໍາເນົາໄຟລ໌ທີ່ມີຢູ່ແລ້ວຫຼື subdirectory ກັບສະຖານທີ່ທີ່ແຕກຕ່າງກັນພາຍໃນ
ສາຂາ. ໄຟລ໌ຫຼືໄດເລກະທໍລີທີ່ມີຢູ່ຕ້ອງມີຢູ່. ຖ້າຈຸດຫມາຍປາຍທາງມີ, ມັນຈະມີ
ຖືກແທນທີ່ຢ່າງສົມບູນໂດຍເນື້ອຫາທີ່ຄັດລອກມາຈາກແຫຼ່ງ.
'ຄ' SP SP LF
ທີ່ນີ້ທໍາອິດ ແມ່ນສະຖານທີ່ແຫຼ່ງແລະທີສອງ ແມ່ນຈຸດຫມາຍປາຍທາງ.
ເບິ່ງ filemodify ຂ້າງເທິງສໍາລັບລາຍລະອຽດລາຍລະອຽດຂອງສິ່ງທີ່ ອາດຈະຄ້າຍຄື. ການນໍາໃຊ້ a
ເສັ້ນທາງແຫຼ່ງທີ່ປະກອບດ້ວຍ SP ເສັ້ນທາງຕ້ອງຖືກອ້າງອີງ.
ຄຳສັ່ງສຳເນົາໄຟລ໌ຈະມີຜົນໃນທັນທີ. ເມື່ອສະຖານທີ່ແຫຼ່ງໄດ້ຖືກຄັດລອກ
ໄປຫາຈຸດຫມາຍປາຍທາງຄໍາສັ່ງໃດໆໃນອະນາຄົດທີ່ໃຊ້ກັບສະຖານທີ່ແຫຼ່ງຈະບໍ່ມີຜົນກະທົບ
ຈຸດຫມາຍປາຍທາງຂອງສໍາເນົາ.
ຊື່ໄຟລ໌
ປ່ຽນຊື່ໄຟລ໌ທີ່ມີຢູ່ແລ້ວ ຫຼືໄດເລກະທໍລີຍ່ອຍເປັນບ່ອນອື່ນພາຍໃນສາຂາ.
ໄຟລ໌ຫຼືໄດເລກະທໍລີທີ່ມີຢູ່ຕ້ອງມີຢູ່. ຖ້າຈຸດຫມາຍປາຍທາງມີຢູ່, ມັນຈະເປັນ
ແທນທີ່ໂດຍໄດເລກະທໍລີແຫຼ່ງ.
'R' SP SP LF
ທີ່ນີ້ທໍາອິດ ແມ່ນສະຖານທີ່ແຫຼ່ງແລະທີສອງ ແມ່ນຈຸດຫມາຍປາຍທາງ.
ເບິ່ງ filemodify ຂ້າງເທິງສໍາລັບລາຍລະອຽດລາຍລະອຽດຂອງສິ່ງທີ່ ອາດຈະຄ້າຍຄື. ການນໍາໃຊ້ a
ເສັ້ນທາງແຫຼ່ງທີ່ປະກອບດ້ວຍ SP ເສັ້ນທາງຕ້ອງຖືກອ້າງອີງ.
ຄໍາສັ່ງ filerename ມີຜົນທັນທີ. ເມື່ອສະຖານທີ່ແຫຼ່ງໄດ້
ປ່ຽນຊື່ໄປຫາຈຸດຫມາຍປາຍທາງ ຄໍາສັ່ງໃດໆໃນອະນາຄົດທີ່ນໍາໃຊ້ກັບສະຖານທີ່ແຫຼ່ງ
ສ້າງໄຟລ໌ໃຫມ່ຢູ່ທີ່ນັ້ນແລະບໍ່ມີຜົນກະທົບຕໍ່ຈຸດຫມາຍປາຍທາງຂອງການປ່ຽນຊື່.
ກະລຸນາຮັບຊາບວ່າຊື່ໄຟລ໌ແມ່ນຄືກັນກັບການສຳເນົາໄຟລ໌ຕາມດ້ວຍການລຶບໄຟລ໌ຂອງ
ທີ່ຕັ້ງແຫຼ່ງ. ມີປະໂຍດການປະຕິບັດເລັກນ້ອຍກັບການໃຊ້ filerename, ແຕ່
ປະໂຫຍດແມ່ນນ້ອຍຫຼາຍຈົນບໍ່ຄຸ້ມຄ່າທີ່ຈະພະຍາຍາມປ່ຽນການລຶບ/ເພີ່ມຄູ່ໃນ
ແຫຼ່ງວັດສະດຸເຂົ້າໄປໃນການປ່ຽນຊື່ສໍາລັບການນໍາເຂົ້າໄວ. ຄໍາສັ່ງ filerename ນີ້ແມ່ນສະຫນອງໃຫ້
ພຽງແຕ່ເພື່ອເຮັດໃຫ້ຫນ້າທີ່ງ່າຍທີ່ມີຂໍ້ມູນການປ່ຽນຊື່ຢູ່ແລ້ວແລະບໍ່ຕ້ອງການ bother
ກັບ decomposing ມັນເຂົ້າໄປໃນໄຟລ໌ສໍາເນົາປະຕິບັດຕາມໂດຍການລຶບໄຟລ໌.
filedeleteall
ລວມຢູ່ໃນຄໍາສັ່ງຄໍາຫມັ້ນສັນຍາທີ່ຈະເອົາໄຟລ໌ທັງຫມົດ (ແລະທັງໄດເລກະທໍລີທັງຫມົດ) ອອກຈາກ
ສາຂາ. ຄໍາສັ່ງນີ້ປັບໂຄງສ້າງສາຂາພາຍໃນໃຫ້ບໍ່ມີໄຟລ໌ຢູ່ໃນມັນ,
ອະນຸຍາດໃຫ້ frontend ຕໍ່ມາເພີ່ມໄຟລ໌ທີ່ຫນ້າສົນໃຈທັງຫມົດຈາກ scratch.
'ລຶບລ້າງ' LF
ຄໍາສັ່ງນີ້ແມ່ນເປັນປະໂຫຍດທີ່ສຸດຖ້າ frontend ບໍ່ຮູ້ (ຫຼືບໍ່ສົນໃຈ
ຮູ້) ໄຟລ໌ໃດທີ່ມີຢູ່ໃນສາຂາ, ແລະດັ່ງນັ້ນຈຶ່ງບໍ່ສາມາດສ້າງທີ່ເຫມາະສົມ
filedelete ຄໍາສັ່ງເພື່ອປັບປຸງເນື້ອຫາ.
ການອອກ filedeleteall ປະຕິບັດຕາມຄໍາສັ່ງ filemodify ທີ່ຈໍາເປັນເພື່ອກໍານົດທີ່ຖືກຕ້ອງ
ເນື້ອຫາຈະຜະລິດຜົນໄດ້ຮັບຄືກັນກັບການສົ່ງໄຟລ໌ທີ່ຕ້ອງການເທົ່ານັ້ນແລະ
filedelete ຄໍາສັ່ງ. ວິທີການ filedeleteall ອາດຈະຮຽກຮ້ອງໃຫ້ມີການນໍາເຂົ້າໄວເພື່ອນໍາໃຊ້
ຫນ່ວຍຄວາມຈໍາເພີ່ມເຕີມເລັກນ້ອຍຕໍ່ສາຂາທີ່ມີການເຄື່ອນໄຫວ (ຫນ້ອຍກວ່າ 1 MiB ສໍາລັບໂຄງການຂະຫນາດໃຫຍ່ທີ່ສຸດ);
ດັ່ງນັ້ນ frontends ທີ່ສາມາດໄດ້ຢ່າງງ່າຍດາຍໄດ້ຮັບພຽງແຕ່ເສັ້ນທາງທີ່ຖືກກະທົບສໍາລັບຄໍາຫມັ້ນສັນຍາແມ່ນ
ຊຸກຍູ້ໃຫ້ເຮັດແນວນັ້ນ.
ດັດແກ້
ຮວມຢູ່ໃນຄຳໝັ້ນສັນຍາ ຄໍາສັ່ງທີ່ຈະເພີ່ມບັນທຶກໃຫມ່ annotating a
ຫຼືປ່ຽນເນື້ອໃນຄໍາອະທິບາຍນີ້. ພາຍໃນມັນຄ້າຍຄືກັບ filemodify 100644 on
ເສັ້ນທາງ (ອາດຈະແບ່ງອອກເປັນໄດເລກະທໍລີຍ່ອຍ). ມັນບໍ່ໄດ້ຖືກແນະນໍາໃຫ້ໃຊ້ອື່ນໆ
ຄໍາສັ່ງທີ່ຈະຂຽນໃສ່ tree ຍົກເວັ້ນ filedeleteall ເພື່ອລຶບທັງໝົດທີ່ມີຢູ່ແລ້ວ
ບັນທຶກໃນຕົ້ນໄມ້ນີ້. ຄໍາສັ່ງນີ້ມີສອງວິທີທີ່ແຕກຕ່າງກັນຂອງການກໍານົດເນື້ອໃນຂອງ
ບັນທຶກ.
ຮູບແບບຂໍ້ມູນພາຍນອກ
ເນື້ອໃນຂໍ້ມູນຂອງບັນທຶກໄດ້ຖືກສະໜອງໃຫ້ໂດຍຄໍາສັ່ງ blob ກ່ອນ. ໄດ້
frontend ພຽງແຕ່ຕ້ອງການເຊື່ອມຕໍ່ມັນກັບຄໍາຫມັ້ນສັນຍາທີ່ຈະຖືກບັນທຶກໄວ້.
'ນ' SP SP LF
ທີ່ນີ້ ສາມາດເປັນເຄື່ອງຫມາຍອ້າງອີງ (: ) ກໍານົດໂດຍ blob ກ່ອນ
ຄໍາສັ່ງ, ຫຼືເຕັມ 40-byte SHA-1 ຂອງວັດຖຸ Git blob ທີ່ມີຢູ່ແລ້ວ.
ຮູບແບບຂໍ້ມູນໃນແຖວ
ເນື້ອໃນຂໍ້ມູນຂອງບັນທຶກຍັງບໍ່ທັນໄດ້ສະໜອງໃຫ້ເທື່ອ. Frontend ຕ້ອງການ
ສະຫນອງມັນເປັນສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງດັດແກ້ນີ້.
'N' SP 'inline' SP LF
ຂໍ້ມູນ
ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບລາຍລະອຽດຂອງຄໍາສັ່ງຂໍ້ມູນ.
ໃນທັງສອງຮູບແບບ ແມ່ນການສະແດງອອກສະເພາະຂອງຄໍາຫມັ້ນສັນຍາໃດໆ
ຍອມຮັບຈາກ (ເບິ່ງຂ້າງເທິງ).
ເຄື່ອງຫມາຍ
ຈັດລຽງການນໍາເຂົ້າໄວເພື່ອບັນທຶກການອ້າງອີງເຖິງວັດຖຸປະຈຸບັນ, ອະນຸຍາດໃຫ້ມີຫນ້າ
ເພື່ອຈື່ຈໍາວັດຖຸນີ້ຢູ່ໃນຈຸດໃນອະນາຄົດ, ໂດຍບໍ່ຮູ້ SHA-1 ຂອງມັນ. ທີ່ນີ້
ວັດຖຸປະຈຸບັນແມ່ນຄໍາສັ່ງສ້າງວັດຖຸທີ່ຄໍາສັ່ງເຄື່ອງຫມາຍປາກົດຢູ່ພາຍໃນ. ນີ້ສາມາດເປັນ
commit, tag, ແລະ blob, ແຕ່ commit ແມ່ນການນໍາໃຊ້ທົ່ວໄປທີ່ສຸດ.
'ເຄື່ອງໝາຍ' SP ':' LF
ຢູ່ໃສ ແມ່ນຕົວເລກທີ່ຖືກມອບໝາຍໂດຍ frontend ໃຫ້ກັບເຄື່ອງໝາຍນີ້. ມູນຄ່າຂອງ ແມ່ນ
ສະແດງເປັນຈຳນວນທົດສະນິຍົມ ASCII. ຄ່າ 0 ຖືກສະຫງວນໄວ້ ແລະບໍ່ສາມາດໃຊ້ເປັນ a
ເຄື່ອງໝາຍ. ພຽງແຕ່ຄ່າທີ່ໃຫຍ່ກວ່າ ຫຼືເທົ່າກັບ 1 ເທົ່ານັ້ນທີ່ສາມາດໃຊ້ເປັນເຄື່ອງໝາຍ.
ເຄື່ອງຫມາຍໃຫມ່ຖືກສ້າງຂື້ນໂດຍອັດຕະໂນມັດ. ເຄື່ອງຫມາຍທີ່ມີຢູ່ສາມາດຍ້າຍໄປທີ່ວັດຖຸອື່ນໄດ້ງ່າຍໆ
ໂດຍການນໍາໃຊ້ອັນດຽວກັນ ໃນຄໍາສັ່ງເຄື່ອງຫມາຍອື່ນ.
ໂຄດຄໍາສັ່ງ
ສ້າງແທັກຄໍາບັນຍາຍໂດຍອ້າງອີງໃສ່ຄໍາຫມັ້ນສັນຍາສະເພາະ. ເພື່ອສ້າງນ້ໍາຫນັກເບົາ
tags (non-annotated) ເບິ່ງຄໍາສັ່ງ reset ຂ້າງລຸ່ມນີ້.
'ແທັກ' SP LF
'ຈາກ' SP LF
'tagger' (SP )? SP LT GT SP LF
ຂໍ້ມູນ
ຢູ່ໃສ ແມ່ນຊື່ຂອງແທັກທີ່ຈະສ້າງ.
ຊື່ແທັກຈະຖືກນຳໜ້າໂດຍອັດຕະໂນມັດດ້ວຍ refs/tags/ ເມື່ອເກັບໄວ້ໃນ Git, ສະນັ້ນການນຳເຂົ້າ.
ສັນຍາລັກສາຂາ CVS RELENG-1_0-FINAL ຈະໃຊ້ພຽງແຕ່ RELENG-1_0-FINAL ສໍາລັບ , ແລະ
fast-import ຈະຂຽນ ref ທີ່ສອດຄ້ອງກັນເປັນ refs/tags/RELENG-1_0-FINAL.
ມູນຄ່າຂອງ ຕ້ອງເປັນຊື່ປ່ຽນທີ່ຖືກຕ້ອງໃນ Git ແລະດັ່ງນັ້ນຈຶ່ງອາດຈະມີການສົ່ງຕໍ່
ທັບ. ເນື່ອງຈາກ LF ບໍ່ຖືກຕ້ອງໃນຊື່ Git refname, ບໍ່ມີການອ້າງອີງຫຼື syntax ຫນີຖືກສະຫນັບສະຫນູນ.
ທີ່ນີ້.
ຄໍາສັ່ງຈາກແມ່ນຄືກັນກັບໃນຄໍາສັ່ງ commit; ເບິ່ງຂ້າງເທິງສໍາລັບລາຍລະອຽດ.
ຄໍາສັ່ງ tagger ໃຊ້ຮູບແບບດຽວກັນກັບ committer ພາຍໃນ commit; ອີກເທື່ອຫນຶ່ງເບິ່ງຂ້າງເທິງສໍາລັບ
ລາຍລະອຽດ.
ຄໍາສັ່ງຂໍ້ມູນດັ່ງຕໍ່ໄປນີ້ tagger ຈະຕ້ອງສະຫນອງຂໍ້ຄວາມ tag annotated (ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບ
syntax ຄໍາສັ່ງຂໍ້ມູນ). ເພື່ອນໍາເຂົ້າຂໍ້ຄວາມແທັກເປົ່າໃຫ້ໃຊ້ຂໍ້ມູນຄວາມຍາວ 0. ຂໍ້ຄວາມແທັກແມ່ນ
free-form ແລະບໍ່ໄດ້ຖືກຕີຄວາມຫມາຍໂດຍ Git. ໃນປັດຈຸບັນພວກເຂົາຕ້ອງໄດ້ຮັບການເຂົ້າລະຫັດໃນ UTF-8, ເປັນ
fast-import ບໍ່ອະນຸຍາດໃຫ້ມີການລະບຸການເຂົ້າລະຫັດອື່ນ.
ບໍ່ຮອງຮັບການລົງນາມແທັກທີ່ລະບຸໄວ້ໃນລະຫວ່າງການນຳເຂົ້າຈາກພາຍໃນໄວ. ພະຍາຍາມ
ບໍ່ແນະນຳໃຫ້ໃສ່ລາຍເຊັນ PGP/GPG ຂອງເຈົ້າເອງ, ເພາະວ່າສ່ວນໜ້າບໍ່ໄດ້ (ງ່າຍ)
ມີການເຂົ້າເຖິງຊຸດເຕັມຂອງ bytes ທີ່ປົກກະຕິເຂົ້າໄປໃນລາຍເຊັນດັ່ງກ່າວ. ຖ້າ
ການລົງນາມແມ່ນຈໍາເປັນ, ສ້າງແທັກທີ່ມີນ້ໍາຫນັກເບົາຈາກພາຍໃນການນໍາເຂົ້າຢ່າງໄວວາດ້ວຍການຕັ້ງໃຫມ່, ຫຼັງຈາກນັ້ນ
ສ້າງສະບັບຫຍໍ້ຂອງ tags ເຫຼົ່ານັ້ນ offline ກັບມາດຕະຖານ ໄປ ໂຄດຄໍາສັ່ງ ຂະບວນການ.
reset
ສ້າງ (ຫຼືສ້າງໃຫມ່) ສາຂາທີ່ມີຊື່, ທາງເລືອກເລີ່ມຕົ້ນຈາກການດັດແກ້ສະເພາະ. ໄດ້
reset command ອະນຸຍາດໃຫ້ frontend ອອກຄໍາສັ່ງໃຫມ່ສໍາລັບສາຂາທີ່ມີຢູ່ແລ້ວ, ຫຼື to
ສ້າງສາຂາໃຫມ່ຈາກຄໍາຫມັ້ນສັນຍາທີ່ມີຢູ່ແລ້ວໂດຍບໍ່ມີການສ້າງຄໍາຫມັ້ນສັນຍາໃຫມ່.
'ປັບ' SP LF
('ຈາກ' SP LF)?
LF?
ສໍາລັບລາຍລະອຽດລາຍລະອຽດຂອງ ແລະ ເບິ່ງຂ້າງເທິງພາຍໃຕ້ຄໍາຫມັ້ນສັນຍາແລະຈາກ.
LF ຫຼັງຈາກຄໍາສັ່ງແມ່ນທາງເລືອກ (ມັນເຄີຍຕ້ອງການ).
ຄໍາສັ່ງຣີເຊັດຍັງສາມາດຖືກນໍາໃຊ້ເພື່ອສ້າງແທໍກທີ່ມີນ້ໍາຫນັກເບົາ (ບໍ່ມີຄໍາບັນຍາຍ). ສໍາລັບ
ຍົກຕົວຢ່າງ:
ຣີເຊັດ refs/tags/938
ຈາກ: 938
ຈະສ້າງແທໍກທີ່ມີນ້ໍາຫນັກເບົາ refs/tags/938 ໂດຍອ້າງອີງໃສ່ອັນໃດກໍໄດ້ commit mark :938
ເອກະສານອ້າງອີງ.
blobs
ຮ້ອງຂໍໃຫ້ຂຽນການດັດແກ້ໄຟລ໌ຫນຶ່ງໄປຫາ packfile. ການແກ້ໄຂບໍ່ໄດ້ເຊື່ອມຕໍ່ກັບອັນໃດ
ຄໍາຫມັ້ນສັນຍາ; ການເຊື່ອມຕໍ່ນີ້ຕ້ອງໄດ້ຮັບການສ້າງຕັ້ງຂຶ້ນໃນຄໍາສັ່ງ commit ຕໍ່ມາໂດຍການອ້າງອີງເຖິງ
blob ຜ່ານເຄື່ອງຫມາຍການມອບຫມາຍ.
'blob' LF
ເຄື່ອງໝາຍ?
ຂໍ້ມູນ
ຄໍາສັ່ງຂອງເຄື່ອງຫມາຍແມ່ນເປັນທາງເລືອກທີ່ນີ້ຍ້ອນວ່າບາງ frontends ໄດ້ເລືອກທີ່ຈະສ້າງ Git SHA-1
ສໍາລັບ blob ຂອງເຂົາເຈົ້າເອງ, ແລະອາຫານທີ່ໂດຍກົງກັບຄໍາຫມັ້ນສັນຍາ. ໂດຍທົ່ວໄປແລ້ວນີ້ແມ່ນວຽກຫຼາຍກວ່າ
ຢ່າງໃດກໍຕາມ, ມັນຄຸ້ມຄ່າກວ່າ, ເພາະວ່າເຄື່ອງຫມາຍມີລາຄາຖືກທີ່ຈະເກັບຮັກສາແລະງ່າຍຕໍ່ການນໍາໃຊ້.
ຂໍ້ມູນ
ສະໜອງຂໍ້ມູນດິບ (ເພື່ອໃຊ້ເປັນເນື້ອໃນ blob/file, commit message, ຫຼື tag annotated
ຂໍ້ຄວາມ) ເພື່ອນໍາເຂົ້າໄວ. ຂໍ້ມູນສາມາດໄດ້ຮັບການສະຫນອງໃຫ້ໂດຍນໍາໃຊ້ການນັບໄບຕ໌ທີ່ແນ່ນອນຫຼື delimited ກັບ
ເສັ້ນຢຸດ. ຫນ້າທີ່ແທ້ຈິງທີ່ມີຈຸດປະສົງສໍາລັບການແປງຄຸນນະພາບການຜະລິດຄວນ
ໃຊ້ຮູບແບບການນັບໄບຕ໌ທີ່ແນ່ນອນສະເໝີ, ເພາະວ່າມັນແຂງແຮງກວ່າ ແລະເຮັດວຽກໄດ້ດີກວ່າ. ໄດ້
ຮູບແບບ delimited ມີຈຸດປະສົງຕົ້ນຕໍສໍາລັບການທົດສອບການນໍາເຂົ້າໄວ.
ແຖວຄຳເຫັນທີ່ປາກົດຢູ່ພາຍໃນ ສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງຂໍ້ມູນແມ່ນສະເຫມີໄປເປັນສ່ວນຫນຶ່ງ
ຂອງຮ່າງກາຍຂອງຂໍ້ມູນແລະດັ່ງນັ້ນຈຶ່ງບໍ່ເຄີຍຖືກລະເລີຍໂດຍການນໍາເຂົ້າໄວ. ນີ້ເຮັດໃຫ້ມັນປອດໄພ
ການນໍາເຂົ້າໄຟລ໌ / ເນື້ອໃນຂໍ້ຄວາມໃດຫນຶ່ງທີ່ສາຍອາດຈະເລີ່ມຕົ້ນດ້ວຍ #.
ຮູບແບບການນັບໄບຕ໌ທີ່ແນ່ນອນ
Frontend ຕ້ອງລະບຸຈໍານວນ bytes ຂອງຂໍ້ມູນ.
'ຂໍ້ມູນ' SP LF
LF?
ຢູ່ໃສ ແມ່ນຕົວເລກທີ່ແນ່ນອນຂອງ bytes ທີ່ປາກົດຢູ່ພາຍໃນ . ມູນຄ່າຂອງ
ສະແດງອອກເປັນຈຳນວນທົດສະນິຍົມ ASCII. LF ທັງສອງຂ້າງຂອງ ແມ່ນ
ບໍ່ລວມຢູ່ໃນ ແລະຈະບໍ່ຖືກລວມເຂົ້າໃນຂໍ້ມູນທີ່ນໍາເຂົ້າ.
LF ຫຼັງຈາກ ເປັນທາງເລືອກ (ມັນເຄີຍຕ້ອງການ) ແຕ່ແນະນໍາ. ສະເໝີ
ລວມທັງມັນເຮັດໃຫ້ debugging stream-import ໄວງ່າຍຂຶ້ນເປັນຄໍາສັ່ງຕໍ່ໄປສະເຫມີ
ເລີ່ມຕົ້ນໃນຖັນ 0 ຂອງແຖວຕໍ່ໄປ, ເຖິງແມ່ນວ່າ ບໍ່ໄດ້ສິ້ນສຸດດ້ວຍ LF.
ຮູບແບບທີ່ຈໍາກັດ
ສະຕຣິງຕົວຂັ້ນແມ່ນໃຊ້ເພື່ອໝາຍຈຸດສິ້ນສຸດຂອງຂໍ້ມູນ. ການນໍາເຂົ້າໄວຈະຄິດໄລ່ໄດ້
ຄວາມຍາວໂດຍການຊອກຫາຕົວຂັ້ນ. ຮູບແບບນີ້ແມ່ນເປັນປະໂຫຍດຕົ້ນຕໍສໍາລັບການທົດສອບແລະ
ບໍ່ແນະນໍາສໍາລັບຂໍ້ມູນທີ່ແທ້ຈິງ.
'ຂໍ້ມູນ' SP '<<' LF
LF
LF
LF?
ຢູ່ໃສ ແມ່ນສາຍຕົວຂັ້ນທີ່ເລືອກ. ຊ່ອຍແນ່ ຈະຕ້ອງບໍ່ປາກົດຢູ່ໃນ a
ເສັ້ນດ້ວຍຕົວມັນເອງພາຍໃນ ຖ້າບໍ່ດັ່ງນັ້ນ, ການນໍາເຂົ້າໄວຈະຄິດວ່າຂໍ້ມູນຈະສິ້ນສຸດລົງໄວກວ່ານີ້
ກ່ວາມັນແທ້ໆ. LF ໄດ້ຕິດຕາມທັນທີ ແມ່ນສ່ວນຫນຶ່ງຂອງ . ນີ້ແມ່ນຫນຶ່ງ
ຂອງຂໍ້ຈໍາກັດຂອງຮູບແບບ delimited, ມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະສະຫນອງ chunk ຂໍ້ມູນ
ເຊິ່ງບໍ່ມີ LF ເປັນໄບຕ໌ສຸດທ້າຍຂອງມັນ.
LF ຫຼັງຈາກ LF ແມ່ນທາງເລືອກ (ມັນເຄີຍຕ້ອງການ).
ດ່ານ
ບັງຄັບໃຫ້ນໍາເຂົ້າໄວເພື່ອປິດແພັກໄຟລ໌ປັດຈຸບັນ, ເລີ່ມອັນໃໝ່ ແລະເພື່ອປະຢັດທັງໝົດ
ສາຂາປະຈຸບັນ, tags ແລະເຄື່ອງຫມາຍ.
'ດ່ານ' LF
LF?
ໃຫ້ສັງເກດວ່າການນໍາເຂົ້າໄວຈະປ່ຽນ packfiles ໂດຍອັດຕະໂນມັດເມື່ອ packfile ມາຮອດປະຈຸບັນ
--max-pack-size, ຫຼື 4 GiB, ຂີດຈຳກັດອັນໃດໜ້ອຍກວ່າ. ໃນລະຫວ່າງການສະຫຼັບ packfile ອັດຕະໂນມັດ
fast-import ບໍ່ໄດ້ປັບປຸງສາຂາ refs, tags ຫຼືເຄື່ອງຫມາຍ.
ໃນຖານະເປັນຈຸດກວດສອບສາມາດຮຽກຮ້ອງໃຫ້ມີຈໍານວນທີ່ສໍາຄັນຂອງ CPU ທີ່ໃຊ້ເວລາແລະ IO ແຜ່ນ (ເພື່ອຄິດໄລ່
packsum SHA-1 ໂດຍລວມ, ສ້າງໄຟລ໌ດັດສະນີທີ່ສອດຄ້ອງກັນ, ແລະປັບປຸງການອ້າງອີງ)
ມັນໄດ້ຢ່າງງ່າຍດາຍສາມາດໃຊ້ເວລາຫຼາຍນາທີສໍາລັບຄໍາສັ່ງດ່ານດຽວເພື່ອໃຫ້ສໍາເລັດ.
Frontends ອາດຈະເລືອກທີ່ຈະອອກດ່ານໃນລະຫວ່າງການນໍາເຂົ້າຂະຫນາດໃຫຍ່ທີ່ສຸດແລະແລ່ນຍາວ,
ຫຼືເມື່ອພວກເຂົາຕ້ອງການອະນຸຍາດໃຫ້ຂະບວນການ Git ອື່ນເຂົ້າເຖິງສາຂາ. ຢ່າງໃດກໍຕາມ, ໃຫ້ 30
GiB Subversion repository ສາມາດຖືກໂຫລດເຂົ້າໄປໃນ Git ໂດຍຜ່ານການນໍາເຂົ້າຢ່າງໄວວາໃນເວລາປະມານ 3 ຊົ່ວໂມງ,
ການກວດກາຢ່າງຈະແຈ້ງອາດຈະບໍ່ຈໍາເປັນ.
LF ຫຼັງຈາກຄໍາສັ່ງແມ່ນທາງເລືອກ (ມັນເຄີຍຕ້ອງການ).
ຄວາມຄືບຫນ້າ
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມເສັ້ນຄວາມຄືບຫນ້າທັງຫມົດ unmodified ກັບຜົນຜະລິດມາດຕະຖານຂອງຕົນ
ຊ່ອງ (ຕົວອະທິບາຍໄຟລ໌ 1) ເມື່ອຄໍາສັ່ງຖືກປະມວນຜົນຈາກກະແສການປ້ອນຂໍ້ມູນ. ໄດ້
ຄໍາ ສັ່ງ ຖ້າ ບໍ່ ດັ່ງ ນັ້ນ ບໍ່ ມີ ຜົນ ກະ ທົບ ຕໍ່ ການ ນໍາ ເຂົ້າ ໃນ ປະ ຈຸ ບັນ, ຫຼື ການ ນໍາ ເຂົ້າ ໄວ ຂອງ ພາຍ ໃນ
ລັດ.
'ຄວາມຄືບໜ້າ' SP LF
LF?
ໄດ້ ສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງອາດຈະປະກອບດ້ວຍລໍາດັບຂອງ bytes ທີ່ບໍ່ມີ LF.
LF ຫຼັງຈາກຄໍາສັ່ງແມ່ນທາງເລືອກ. ຜູ້ໂທອາດຈະຕ້ອງການທີ່ຈະປະມວນຜົນຜົນຜະລິດໂດຍຜ່ານ a
ເຄື່ອງມືເຊັ່ນ: sed ເພື່ອເອົາສ່ວນຊັ້ນນໍາຂອງເສັ້ນ, ຕົວຢ່າງ:
ດ້ານໜ້າ | git ໄວນໍາເຂົ້າ | sed 's/^ ຄວາມຄືບໜ້າ //'
ການວາງຄໍາສັ່ງຄວາມຄືບຫນ້າທັນທີຫຼັງຈາກຈຸດກວດກາຈະແຈ້ງໃຫ້ຜູ້ອ່ານໄດ້ໃນເວລາທີ່
ດ່ານກວດໄດ້ສຳເລັດແລ້ວ ແລະມັນສາມາດເຂົ້າເຖິງເອກະສານອ້າງອີງທີ່ອັບເດດການນຳເຂົ້າໄດ້ຢ່າງປອດໄພ.
ຮັບເຄື່ອງໝາຍ
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມ SHA-1 ທີ່ສອດຄ້ອງກັນກັບເຄື່ອງຫມາຍທີ່ຈະ stdout ຫຼືໄຟລ໌.
descriptor ຜ່ານມາຈັດລຽງດ້ວຍ argument --cat-blob-fd. ຄໍາສັ່ງຖ້າບໍ່ດັ່ງນັ້ນມີ
ບໍ່ມີຜົນກະທົບຕໍ່ການນໍາເຂົ້າໃນປະຈຸບັນ; ຈຸດປະສົງຂອງມັນແມ່ນເພື່ອດຶງຂໍ້ມູນ SHA-1s ທີ່ຕໍ່ມາຄໍາຫມັ້ນສັນຍາ
ອາດຈະຕ້ອງການອ້າງອີງໃນຂໍ້ຄວາມຄໍາຫມັ້ນສັນຍາຂອງພວກເຂົາ.
'get-mark' SP ':' LF
ຄໍາສັ່ງນີ້ສາມາດຖືກນໍາໃຊ້ທຸກບ່ອນໃນກະແສທີ່ຄໍາເຫັນຖືກຍອມຮັບ. ໂດຍສະເພາະ,
ຄໍາສັ່ງ get-mark ສາມາດຖືກນໍາໃຊ້ໃນກາງຂອງຄໍາຫມັ້ນສັນຍາແຕ່ບໍ່ແມ່ນຢູ່ໃນກາງຂອງຂໍ້ມູນ
ຄໍາສັ່ງ.
ເບິ່ງ “ການຕອບສະໜອງຕໍ່ຄຳສັ່ງ” ຂ້າງລຸ່ມນີ້ສຳລັບລາຍລະອຽດກ່ຽວກັບວິທີການອ່ານຜົນໄດ້ຮັບນີ້ຢ່າງປອດໄພ.
cat-blob
ເຮັດໃຫ້ການນໍາເຂົ້າໄວເພື່ອພິມ blob ໄປຫາຕົວອະທິບາຍໄຟລ໌ທີ່ຈັດລຽງກ່ອນຫນ້າດ້ວຍ
--cat-blob-fd argument. ຄໍາສັ່ງຖ້າບໍ່ດັ່ງນັ້ນບໍ່ມີຜົນກະທົບຕໍ່ການນໍາເຂົ້າໃນປະຈຸບັນ; ຂອງມັນ
ຈຸດປະສົງຕົ້ນຕໍແມ່ນເພື່ອດຶງຂໍ້ມູນ blobs ທີ່ອາດຈະຢູ່ໃນຄວາມຊົງຈໍາຂອງການນໍາເຂົ້າໄວແຕ່ບໍ່ສາມາດເຂົ້າເຖິງ
ຈາກ repository ເປົ້າຫມາຍ.
'cat-blob' SP LF
ໄດ້ ສາມາດເປັນເຄື່ອງຫມາຍອ້າງອີງ (: ) ທີ່ກໍານົດໄວ້ກ່ອນຫນ້ານີ້ຫຼືເຕັມ 40-byte
SHA-1 ຂອງ Git blob, ມີຢູ່ກ່ອນ ຫຼືພ້ອມທີ່ຈະຂຽນ.
ຜົນຜະລິດໃຊ້ຮູບແບບດຽວກັນກັບ git cat-file --batch:
SP 'blob' SP LF
LF
ຄໍາສັ່ງນີ້ສາມາດຖືກນໍາໃຊ້ທຸກບ່ອນໃນກະແສທີ່ຄໍາເຫັນຖືກຍອມຮັບ. ໂດຍສະເພາະ,
ຄໍາສັ່ງ cat-blob ສາມາດຖືກນໍາໃຊ້ຢູ່ໃນກາງຂອງຄໍາຫມັ້ນສັນຍາແຕ່ບໍ່ແມ່ນຢູ່ໃນກາງຂອງຂໍ້ມູນ
ຄໍາສັ່ງ.
ເບິ່ງ “ການຕອບສະໜອງຕໍ່ຄຳສັ່ງ” ຂ້າງລຸ່ມນີ້ສຳລັບລາຍລະອຽດກ່ຽວກັບວິທີການອ່ານຜົນໄດ້ຮັບນີ້ຢ່າງປອດໄພ.
ls
ພິມຂໍ້ມູນກ່ຽວກັບວັດຖຸຢູ່ໃນເສັ້ນທາງໄປຫາຕົວອະທິບາຍໄຟລ໌ທີ່ຈັດໄວ້ກ່ອນຫນ້ານີ້
ດ້ວຍການໂຕ້ຖຽງ --cat-blob-fd. ນີ້ອະນຸຍາດໃຫ້ພິມ blob ຈາກຄໍາຫມັ້ນສັນຍາການເຄື່ອນໄຫວ (ມີ
cat-blob) ຫຼືການຄັດລອກ blob ຫຼືຕົ້ນໄມ້ຈາກຄໍາຫມັ້ນສັນຍາທີ່ຜ່ານມາສໍາລັບການນໍາໃຊ້ໃນປະຈຸບັນ
(ມີ filemodify).
ຄໍາສັ່ງ ls ສາມາດນໍາໃຊ້ໄດ້ທຸກບ່ອນໃນກະແສທີ່ຄໍາເຫັນຖືກຍອມຮັບ, ລວມທັງ
ກາງຂອງຄໍາຫມັ້ນສັນຍາ.
ການອ່ານຈາກຄໍາຫມັ້ນສັນຍາທີ່ຫ້າວຫັນ
ແບບຟອມນີ້ສາມາດໃຊ້ໄດ້ໃນກາງຄໍາໝັ້ນສັນຍາເທົ່ານັ້ນ. ເສັ້ນທາງຕັ້ງຊື່ລາຍການໄດເລກະທໍລີ
ພາຍໃນຄໍາຫມັ້ນສັນຍາການນໍາເຂົ້າໄວ. ໃນກໍລະນີດັ່ງກ່າວນີ້, ເສັ້ນທາງຕ້ອງໄດ້ຮັບການອ້າງອີງ.
'ls' SP LF
ການອ່ານຈາກຕົ້ນໄມ້ທີ່ມີຊື່
ໄດ້ ສາມາດເປັນເຄື່ອງໝາຍອ້າງອີງ (: ) ຫຼື SHA-40 ເຕັມ 1-byte ຂອງ Git
tag, commit, or tree object, preexisting ຫຼືລໍຖ້າທີ່ຈະຂຽນ. ເສັ້ນທາງແມ່ນ
ທຽບກັບລະດັບສູງສຸດຂອງຕົ້ນໄມ້ທີ່ມີຊື່ໂດຍ .
'ls' SP SP LF
ເບິ່ງ filemodify ຂ້າງເທິງສໍາລັບລາຍລະອຽດລາຍລະອຽດຂອງ .
ຜົນຜະລິດໃຊ້ຮູບແບບດຽວກັນກັບ git ls-tree -- :
SP ('blob' | 'ຕົ້ນໄມ້' | 'commit') SP ຮຕ LF
ໄດ້ ເປັນຕົວແທນຂອງ blob, ຕົ້ນໄມ້, ຫຼືວັດຖຸຄໍາຫມັ້ນສັນຍາທີ່ ແລະສາມາດນໍາໃຊ້ໃນ
ຕໍ່ມາ ຮັບເຄື່ອງໝາຍ, cat-blob, ແກ້ໄຂໄຟລ໌, ຫຼື ls ຄຳ ສັ່ງ.
ຖ້າບໍ່ມີໄຟລ໌ ຫຼືຕົ້ນໄມ້ຍ່ອຍຢູ່ໃນເສັ້ນທາງນັ້ນ, ໄປ ການນໍາເຂົ້າໄວ ແທນທີ່ຈະລາຍງານ
SP ຂາດ LF
ເບິ່ງ “ການຕອບສະໜອງຕໍ່ຄຳສັ່ງ” ຂ້າງລຸ່ມນີ້ສຳລັບລາຍລະອຽດກ່ຽວກັບວິທີການອ່ານຜົນໄດ້ຮັບນີ້ຢ່າງປອດໄພ.
ຄຸນນະສົມບັດ
ຮຽກຮ້ອງໃຫ້ມີການນໍາເຂົ້າໄວສະຫນັບສະຫນູນຄຸນນະສົມບັດທີ່ລະບຸໄວ້, ຫຼືຍົກເລີກຖ້າຫາກວ່າມັນບໍ່ໄດ້.
'ຄຸນສົມບັດ' SP ('=' )? LF
ໄດ້ ສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງອາດຈະເປັນຫນຶ່ງຕໍ່ໄປນີ້:
ຮູບແບບວັນທີ, ເຄື່ອງຫມາຍການສົ່ງອອກ, ເຄື່ອງຫມາຍພີ່ນ້ອງກັນ, ບໍ່ມີພີ່ນ້ອງກັນເຄື່ອງຫມາຍ, ຜົນບັງຄັບໃຊ້
ປະຕິບັດເປັນທາງເລືອກເສັ້ນຄໍາສັ່ງທີ່ສອດຄ້ອງກັນດ້ວຍການນໍາພາ -- ໄດ້ຜ່ານ
ເສັ້ນຄໍາສັ່ງ (ເບິ່ງ OPTIONS, ຂ້າງເທິງ).
ເຄື່ອງຫມາຍການນໍາເຂົ້າ, ເຄື່ອງຫມາຍການນໍາເຂົ້າ - ຖ້າມີ
ເຊັ່ນດຽວກັນກັບ --import-marks ຍົກເວັ້ນໃນສອງດ້ານ: ທໍາອິດ, ພຽງແຕ່ຫນຶ່ງ "ຄຸນນະສົມບັດການນໍາເຂົ້າເຄື່ອງຫມາຍ" ຫຼື
ຄໍາສັ່ງ "feature import-marks-if-exists" ແມ່ນອະນຸຍາດຕໍ່ກະແສ; ອັນທີສອງ, ເປັນ
--import-marks= ຫຼື --import-marks-if-exists ທາງເລືອກແຖວຄໍາສັ່ງ overrides ອັນໃດນຶ່ງເຫຼົ່ານີ້
"ຄຸນສົມບັດ" ຄໍາສັ່ງໃນນ້ໍາ; ອັນທີສາມ, "ຄຸນນະສົມບັດການນໍາເຂົ້າເຄື່ອງຫມາຍ - ຖ້າມີ" ເຊັ່ນ: a
ຕົວເລືອກແຖວຄໍາສັ່ງທີ່ສອດຄ້ອງກັນຈະຂ້າມໄຟລ໌ທີ່ບໍ່ມີຢູ່ຢ່າງງຽບໆ.
get-mark, cat-blob, ls
ຮຽກຮ້ອງໃຫ້ backend ສະຫນັບສະຫນູນ ຮັບເຄື່ອງໝາຍ, cat-blob, ຫຼື ls ຄໍາສັ່ງຕາມລໍາດັບ.
ເວີຊັນຂອງການນໍາເຂົ້າໄວທີ່ບໍ່ຮອງຮັບຄໍາສັ່ງທີ່ລະບຸໄວ້ຈະອອກດ້ວຍຂໍ້ຄວາມ
ສະແດງໃຫ້ເຫັນດັ່ງນັ້ນ. ນີ້ເຮັດໃຫ້ຄວາມຜິດພາດການນໍາເຂົ້າອອກໄວໂດຍຂໍ້ຄວາມທີ່ຊັດເຈນ, ແທນທີ່ຈະ
ການເສຍເວລາໃນຕອນຕົ້ນຂອງການນໍາເຂົ້າກ່ອນທີ່ຄໍາສັ່ງທີ່ບໍ່ໄດ້ຮັບການສະຫນັບສະຫນູນແມ່ນ
ກວດພົບ.
ອ່ືນ
ຮຽກຮ້ອງໃຫ້ backend ສະຫນັບສະຫນູນ ດັດແກ້ (N) ຄໍາສັ່ງຍ່ອຍຂອງ ຄໍາຫມັ້ນສັນຍາ ຄໍາສັ່ງ.
ລຸ້ນຂອງບັນທຶກການນຳເຂົ້າໄວທີ່ບໍ່ຮອງຮັບຈະອອກໂດຍມີຂໍ້ຄວາມທີ່ຊີ້ບອກ.
ເຮັດ
ຜິດພາດຖ້າຫາກວ່າການຖ່າຍທອດສິ້ນສຸດລົງໂດຍບໍ່ມີການ a ເຮັດ ຄໍາສັ່ງ. ບໍ່ມີຄຸນສົມບັດນີ້, ຄວາມຜິດພາດ
ເຮັດໃຫ້ frontend ສິ້ນສຸດລົງຢ່າງກະທັນຫັນໃນຈຸດສະດວກໃນສາຍນ້ໍາສາມາດໄປ
ບໍ່ກວດພົບ. ນີ້ອາດຈະເກີດຂຶ້ນ, ສໍາລັບການຍົກຕົວຢ່າງ, ຖ້າການນໍາເຂົ້າດ້ານຫນ້າຕາຍໃນກາງການດໍາເນີນງານ
ໂດຍບໍ່ມີການປ່ອຍ SIGTERM ຫຼື SIGKILL ຢູ່ໃນຕົວຢ່າງການນໍາເຂົ້າໄວ git subordinate ຂອງມັນ.
ທາງເລືອກ
ປະມວນຜົນທາງເລືອກທີ່ລະບຸໄວ້ເພື່ອໃຫ້ git ການນໍາເຂົ້າໄວປະຕິບັດໃນວິທີການທີ່ເຫມາະສົມ
ຄວາມຕ້ອງການຂອງ frontend. ໃຫ້ສັງເກດວ່າທາງເລືອກທີ່ລະບຸໄວ້ໂດຍ frontend ແມ່ນ overridden ໂດຍໃດໆ
ທາງເລືອກທີ່ຜູ້ໃຊ້ອາດຈະລະບຸເພື່ອ git ໄວນໍາເຂົ້າຕົວມັນເອງ.
'ທາງເລືອກ' SP LF
ໄດ້ ສ່ວນຫນຶ່ງຂອງຄໍາສັ່ງອາດມີທາງເລືອກໃດນຶ່ງທີ່ລະບຸໄວ້ໃນ OPTIONS
ພາກສ່ວນທີ່ບໍ່ປ່ຽນແປງການນໍາເຂົ້າ, ໂດຍບໍ່ມີການນໍາ -- ແລະໄດ້ຮັບການປິ່ນປົວໃນ
ວິທີການດຽວກັນ.
ຄໍາສັ່ງທາງເລືອກຕ້ອງເປັນຄໍາສັ່ງທໍາອິດກ່ຽວກັບການປ້ອນຂໍ້ມູນ (ບໍ່ນັບຄໍາສັ່ງຄຸນນະສົມບັດ),
ເພື່ອໃຫ້ຄໍາສັ່ງທາງເລືອກຫຼັງຈາກຄໍາສັ່ງທີ່ບໍ່ມີທາງເລືອກແມ່ນຄວາມຜິດພາດ.
ຕົວເລືອກແຖວຄໍາສັ່ງຕໍ່ໄປນີ້ຈະປ່ຽນຄວາມຫມາຍການນໍາເຂົ້າ ແລະດັ່ງນັ້ນອາດຈະບໍ່ຜ່ານ
ເປັນທາງເລືອກ:
· ຮູບແບບວັນທີ
·ເຄື່ອງຫມາຍການນໍາເຂົ້າ
·ເຄື່ອງໝາຍສົ່ງອອກ
· cat-blob-fd
· ຜົນບັງຄັບໃຊ້
ເຮັດ
ຖ້າຄຸນສົມບັດທີ່ເຮັດແລ້ວບໍ່ໄດ້ຖືກນໍາໃຊ້, ປະຕິບັດຄືກັບວ່າ EOF ໄດ້ຖືກອ່ານ. ນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອບອກ
ການນໍາເຂົ້າໄວທີ່ຈະສໍາເລັດໄວ.
ຖ້າຕົວເລືອກເສັ້ນຄໍາສັ່ງ --done ຫຼືຄຸນນະສົມບັດຄໍາສັ່ງທີ່ເຮັດໄດ້ຖືກນໍາໃຊ້, ຄໍາສັ່ງສໍາເລັດແມ່ນ
ບັງຄັບ ແລະໝາຍເຖິງຈຸດສິ້ນສຸດຂອງກະແສ.
ຕອບແທນ ເຖິງ ສາມາດ
ວັດຖຸໃຫມ່ທີ່ຂຽນໂດຍການນໍາເຂົ້າໄວແມ່ນບໍ່ສາມາດໃຊ້ໄດ້ໃນທັນທີ. ການນໍາເຂົ້າໄວທີ່ສຸດ
ຄໍາສັ່ງບໍ່ມີຜົນກະທົບທີ່ເຫັນໄດ້ຈົນກ່ວາການກວດກາຕໍ່ໄປ (ຫຼືສໍາເລັດ). ດ້ານໜ້າ
ສາມາດສົ່ງຄໍາສັ່ງເພື່ອຕື່ມຂໍ້ມູນໃສ່ທໍ່ວັດສະດຸປ້ອນຂອງໄວໄດ້ໂດຍບໍ່ຕ້ອງກັງວົນວ່າພວກມັນໄວເທົ່າໃດ
ຈະມີຜົນ, ເຊິ່ງປັບປຸງການປະຕິບັດໂດຍການເຮັດໃຫ້ການກໍານົດເວລາງ່າຍຂຶ້ນ.
ສໍາລັບບາງຫນ້າ, ເຖິງແມ່ນວ່າ, ມັນເປັນປະໂຫຍດທີ່ຈະສາມາດອ່ານຂໍ້ມູນກັບຄືນໄປບ່ອນຈາກປະຈຸບັນ
repository ຍ້ອນວ່າມັນກໍາລັງຖືກປັບປຸງ (ຕົວຢ່າງເຊັ່ນເມື່ອອຸປະກອນແຫຼ່ງອະທິບາຍວັດຖຸ
ໃນຂໍ້ກໍານົດຂອງ patches ທີ່ຈະນໍາໃຊ້ກັບວັດຖຸທີ່ນໍາເຂົ້າຜ່ານມາ). ນີ້ສາມາດເປັນ
ສໍາເລັດໂດຍການເຊື່ອມຕໍ່ frontend ແລະການນໍາເຂົ້າໄວໂດຍຜ່ານທໍ່ bidirectional:
mkfifo ໄວການນໍາເຂົ້າຜົນຜະລິດ
ດ້ານໜ້າ
git fast-import>fast-import-output
ການຕິດຕັ້ງຫນ້າທາງຫນ້ານີ້ສາມາດໃຊ້ຄໍາສັ່ງກ້າວຫນ້າ, get-mark, ls, ແລະ cat-blob ເພື່ອອ່ານ
ຂໍ້ມູນຈາກການນໍາເຂົ້າທີ່ກໍາລັງດໍາເນີນຢູ່.
ເພື່ອຫຼີກເວັ້ນການຢຸດຊະງັກ, frontends ດັ່ງກ່າວຕ້ອງບໍລິໂພກຜົນຜະລິດທີ່ຍັງຄ້າງໃດໆຈາກ
ຄວາມຄືບຫນ້າ, ls, get-mark, ແລະ cat-blob ກ່ອນທີ່ຈະດໍາເນີນການຂຽນໄປຫາໄວນໍາເຂົ້າທີ່ອາດຈະ
block.
ລົດແຕກ ບົດລາຍງານ
ຖ້າການນໍາເຂົ້າໄວແມ່ນສະຫນອງໃຫ້ການປ້ອນຂໍ້ມູນທີ່ບໍ່ຖືກຕ້ອງມັນຈະຢຸດເຊົາການມີສະຖານະການອອກທີ່ບໍ່ແມ່ນສູນແລະ
ສ້າງບົດລາຍງານການຂັດຂ້ອງໃນລະດັບສູງສຸດຂອງບ່ອນເກັບມ້ຽນ Git ທີ່ມັນຖືກນໍາເຂົ້າ. ອຸປະຕິເຫດ
ບົດລາຍງານມີພາບລວມຂອງລັດການນໍາເຂົ້າໄວພາຍໃນເຊັ່ນດຽວກັນກັບຫລ້າສຸດ
ຄໍາສັ່ງທີ່ນໍາໄປສູ່ການ crash ໄດ້.
ຄໍາສັ່ງທີ່ຜ່ານມາທັງຫມົດ (ລວມທັງຄໍາເຫັນນ້ໍາ, ການປ່ຽນແປງໄຟລ໌ແລະຄໍາສັ່ງກ້າວຫນ້າ) ແມ່ນ
ສະແດງໃຫ້ເຫັນໃນປະຫວັດຄໍາສັ່ງພາຍໃນບົດລາຍງານ crash, ແຕ່ຂໍ້ມູນໄຟລ໌ດິບແລະຄໍາຫມັ້ນສັນຍາ
ຂໍ້ຄວາມຖືກຍົກເວັ້ນຈາກລາຍງານການຂັດຂ້ອງ. ການຍົກເວັ້ນນີ້ຊ່ວຍປະຫຍັດພື້ນທີ່ພາຍໃນບົດລາຍງານ
ໄຟລ໌ແລະຫຼຸດຜ່ອນຈໍານວນ buffering ທີ່ໄວນໍາເຂົ້າຕ້ອງດໍາເນີນການໃນລະຫວ່າງການປະຕິບັດ.
ຫຼັງຈາກການຂຽນບົດລາຍງານອຸປະຕິເຫດການນໍາເຂົ້າໄວຈະປິດ packfile ປະຈຸບັນແລະສົ່ງອອກໄດ້
ຕາຕະລາງເຄື່ອງຫມາຍ. ນີ້ອະນຸຍາດໃຫ້ນັກພັດທະນາ frontend ກວດສອບສະຖານະ repository ແລະ resume
ການນໍາເຂົ້າຈາກຈຸດທີ່ມັນ crashed. ສາຂາທີ່ດັດແກ້ແລະ tags ບໍ່ໄດ້ຖືກປັບປຸງ
ໃນລະຫວ່າງການອຸປະຕິເຫດ, ເນື່ອງຈາກວ່າການນໍາເຂົ້າບໍ່ສໍາເລັດຢ່າງສໍາເລັດຜົນ. ຂໍ້ມູນສາຂາ ແລະແທັກ
ສາມາດພົບໄດ້ໃນລາຍງານການຂັດຂ້ອງ ແລະຕ້ອງຖືກນຳໃຊ້ດ້ວຍຕົນເອງ ຖ້າຕ້ອງການການອັບເດດ.
ອຸປະຕິເຫດຕົວຢ່າງ:
$ cat >in <
# ການທົດສອບຄັ້ງທຳອິດຂອງຂ້ອຍ
commit refs/heads/master
ກໍາມະການ Shawn O. Pearce 19283 -0400
#ຄົນນັ້ນແມ່ນໃຜ?
ຂໍ້ມູນ <
ນີ້ແມ່ນຄໍາຫມັ້ນສັນຍາຂອງຂ້ອຍ
EOF
M 644 inline .gitignore
ຂໍ້ມູນ <
.gitignore
EOF
M 777 inline bob
END_OF_INPUT
$ git ໄວນໍາເຂົ້າ
fatal: ຮູບແບບການສໍ້ລາດບັງຫຼວງ: M 777 inline bob
ນຳເຂົ້າໄວ: ການຖິ້ມລາຍງານການຂັດຂ້ອງໄປຫາ .git/fast_import_crash_8434
$ cat .git/fast_import_crash_8434
ບົດລາຍງານການນໍາເຂົ້າລົ້ມໄວ:
ຂະບວນການນໍາເຂົ້າໄວ: 8434
ຂະບວນການຂອງພໍ່ແມ່: 1391
at Sep 1 00:58:12 2007
fatal: ຮູບແບບການສໍ້ລາດບັງຫຼວງ: M 777 inline bob
ຄໍາສັ່ງຫຼ້າສຸດກ່ອນທີ່ຈະ crash
---------------------------------
# ການທົດສອບຄັ້ງທຳອິດຂອງຂ້ອຍ
commit refs/heads/master
ກໍາມະການ Shawn O. Pearce 19283 -0400
#ຄົນນັ້ນແມ່ນໃຜ?
ຂໍ້ມູນ <
M 644 inline .gitignore
ຂໍ້ມູນ <
* M 777 inline bob
ສາຂາທີ່ເຄື່ອນໄຫວ LRU
-----------------
active_branches = 1 cur, ສູງສຸດ 5
ຊື່ໂມງ pos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) 0 refs/heads/master
ສາຂາທີ່ບໍ່ເຄື່ອນໄຫວ
-----------------
ອ້າງອີງ/ຫົວໜ້າ/ແມ່ບົດ:
ສະຖານະພາບ : active loaded ເປື້ອນ
ສັນຍາທິບ : 0000000000000000000000000000000000000000
ຕົ້ນໄມ້ເກົ່າ: 0000000000000000000000000000000000000000
ຕົ້ນໄມ້ : 0000000000000000000000000000000000000000
ໂມງຄຳໝັ້ນສັນຍາ: 0
ຊຸດສຸດທ້າຍ:
-------------------
ສິ້ນສຸດການລາຍງານອຸປະຕິເຫດ
ເຄັດລັບການ ແລະ ການທົດລອງ
ຄໍາແນະນໍາແລະ tricks ດັ່ງຕໍ່ໄປນີ້ໄດ້ຖືກເກັບກໍາຈາກຜູ້ໃຊ້ຕ່າງໆຂອງການນໍາເຂົ້າໄວ, ແລະ
ສະເຫນີຢູ່ທີ່ນີ້ເປັນຄໍາແນະນໍາ.
ການນໍາໃຊ້ ຫນຶ່ງ ເຄື່ອງຫມາຍ ຕໍ່ ຄໍາຫມັ້ນສັນຍາ
ໃນເວລາທີ່ເຮັດການປ່ຽນແປງ repository, ໃຊ້ເຄື່ອງຫມາຍທີ່ເປັນເອກະລັກຕໍ່ຄໍາຫມັ້ນສັນຍາ (ຫມາຍ : ) ແລະການສະຫນອງ
ທາງເລືອກ --export-marks ໃນແຖວຄໍາສັ່ງ. ການນໍາເຂົ້າໄວຈະ dump ໄຟລ໌ທີ່ມີລາຍການ
ທຸກໆເຄື່ອງຫມາຍແລະວັດຖຸ Git SHA-1 ທີ່ສອດຄ້ອງກັບມັນ. ຖ້າ frontend ສາມາດມັດໄດ້
marks ກັບຄືນໄປບ່ອນ repository ແຫຼ່ງ, ມັນງ່າຍທີ່ຈະກວດສອບຄວາມຖືກຕ້ອງແລະຄວາມສົມບູນຂອງ
ການນໍາເຂົ້າໂດຍການປຽບທຽບແຕ່ລະ Git ຄໍາຫມັ້ນສັນຍາກັບການແກ້ໄຂແຫຼ່ງທີ່ສອດຄ້ອງກັນ.
ມາຈາກລະບົບເຊັ່ນ Perforce ຫຼື Subversion ນີ້ຄວນຈະຂ້ອນຂ້າງງ່າຍດາຍ, ເປັນ
ເຄື່ອງຫມາຍການນໍາເຂົ້າໄວຍັງສາມາດເປັນຈໍານວນ Perforce changeset ຫຼືການແກ້ໄຂ Subversion
ຈໍານວນ
ຢ່າງອິດສະຫຼະ ຂ້າມ ປະມານ ສາຂາ
ຢ່າເບື່ອໜ່າຍ ພະຍາຍາມປັບແຕ່ງສ່ວນໜ້າໃຫ້ຕິດຢູ່ກັບສາຂາດຽວໃນເວລານັ້ນ
ນໍາເຂົ້າ. ເຖິງແມ່ນວ່າການເຮັດດັ່ງນັ້ນອາດຈະໄວຂຶ້ນເລັກນ້ອຍສໍາລັບການນໍາເຂົ້າໄວ, ມັນມີແນວໂນ້ມທີ່ຈະເພີ່ມຂຶ້ນ
ຄວາມສັບສົນຂອງລະຫັດ frontend ຢ່າງຫຼວງຫຼາຍ.
ສາຂາ LRU buildin ໃນການນໍາເຂົ້າໄວມີແນວໂນ້ມທີ່ຈະປະຕິບັດໄດ້ດີຫຼາຍ, ແລະຄ່າໃຊ້ຈ່າຍຂອງ
ການເປີດໃຊ້ງານສາຂາທີ່ບໍ່ເຄື່ອນໄຫວແມ່ນຕໍ່າຫຼາຍຈົນເຮັດໃຫ້ການເຄື່ອນທີ່ລະຫວ່າງສາຂາມີ
ເກືອບບໍ່ມີຜົນຕໍ່ການປະຕິບັດການນໍາເຂົ້າ.
ການຈັດການ ປ່ຽນຊື່
ໃນເວລາທີ່ການນໍາເຂົ້າໄຟລ໌ທີ່ປ່ຽນຊື່ຫຼືລະບົບ, ພຽງແຕ່ລົບຊື່ເກົ່າແລະປັບປຸງແກ້ໄຂ
ຊື່ໃຫມ່ໃນລະຫວ່າງຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນ. Git ດໍາເນີນການກວດສອບການປ່ຽນຊື່ຫຼັງຈາກຄວາມຈິງ,
ແທນທີ່ຈະເວົ້າຢ່າງຈະແຈ້ງໃນລະຫວ່າງການໃຫ້ຄຳໝັ້ນສັນຍາ.
ການນໍາໃຊ້ Tag ສ້ອມແປງ ສາຂາ
ບາງລະບົບ SCM ອື່ນໆໃຫ້ຜູ້ໃຊ້ສ້າງແທັກຈາກຫຼາຍໄຟລ໌ທີ່ບໍ່ໄດ້ມາຈາກ
ສັນຍາ / ການປ່ຽນແປງດຽວກັນ. ຫຼືເພື່ອສ້າງແທັກທີ່ເປັນຊຸດຍ່ອຍຂອງໄຟລ໌ທີ່ມີຢູ່ໃນ
ຄັງເກັບມ້ຽນ.
ການນໍາເຂົ້າແທັກເຫຼົ່ານີ້ຢູ່ໃນ Git ແມ່ນເປັນໄປບໍ່ໄດ້ໂດຍບໍ່ມີການເຮັດຢ່າງຫນ້ອຍຫນຶ່ງຄໍາຫມັ້ນສັນຍາທີ່
"ແກ້ໄຂ" ໄຟລ໌ເພື່ອໃຫ້ກົງກັບເນື້ອຫາຂອງແທັກ. ໃຊ້ຄໍາສັ່ງ reset ຂອງ fast-import ເປັນ
ຣີເຊັດສາຂາ dummy ຢູ່ນອກພື້ນທີ່ສາຂາປົກກະຕິຂອງເຈົ້າເປັນຖານທີ່ຕັ້ງໄວ້ສຳລັບແທັກ,
ຫຼັງຈາກນັ້ນຄໍາຫມັ້ນສັນຍາຫນຶ່ງຫຼືຫຼາຍໄຟລ໌ fixup commits, ແລະສຸດທ້າຍໂຄດຄໍາສັ່ງສາຂາ dummy.
ຍົກຕົວຢ່າງນັບຕັ້ງແຕ່ສາຂາປົກກະຕິທັງຫມົດແມ່ນໄດ້ຮັບການເກັບຮັກສາໄວ້ພາຍໃຕ້ refs / ຫົວຫນ້າ / ຊື່ fixup tag
ສາຂາ TAG_FIXUP. ວິທີນີ້ມັນເປັນໄປບໍ່ໄດ້ສໍາລັບສາຂາ fixup ທີ່ໃຊ້ໂດຍຜູ້ນໍາເຂົ້າ
ມີ namespace ຂັດກັບສາຂາທີ່ແທ້ຈິງທີ່ນໍາເຂົ້າມາຈາກແຫຼ່ງ (ຊື່ TAG_FIXUP
ບໍ່ແມ່ນ refs/heads/TAG_FIXUP).
ໃນເວລາທີ່ຄໍາຫມັ້ນສັນຍາ fixups, ພິຈາລະນາການນໍາໃຊ້ merge ເພື່ອເຊື່ອມຕໍ່ຄໍາຫມັ້ນສັນຍາ (s) ທີ່ສະຫນອງໃຫ້
ໄຟລ໌ດັດແກ້ກັບສາຂາ fixup. ການເຮັດດັ່ງນັ້ນຈະອະນຸຍາດໃຫ້ເຄື່ອງມືເຊັ່ນ ໄປ ໂທດ ການຕິດຕາມ
ຜ່ານການປະຫວັດສາດທີ່ແທ້ຈິງແລະຄໍາອະທິບາຍຢ່າງຖືກຕ້ອງຂອງໄຟລ໌ທີ່ມາ.
ຫຼັງຈາກການນໍາເຂົ້າໄວຢຸດເຊົາການ frontend ຈະຕ້ອງເຮັດ rm .git/TAG_FIXUP ເພື່ອເອົາອອກ
ສາຂາ dummy.
ການນໍາເຂົ້າ ໃນປັດຈຸບັນ, ປະຕິເສດ ຕໍ່ມາ
ທັນທີທີ່ການນໍາເຂົ້າໄວສໍາເລັດ, Git repository ແມ່ນຖືກຕ້ອງສົມບູນແລະພ້ອມສໍາລັບການນໍາໃຊ້.
ໂດຍປົກກະຕິ, ນີ້ໃຊ້ເວລາພຽງແຕ່ສັ້ນຫຼາຍ, ເຖິງແມ່ນວ່າສໍາລັບໂຄງການຂະຫນາດໃຫຍ່ຢ່າງຫຼວງຫຼາຍ
(100,000+ ຄໍາຫມັ້ນສັນຍາ).
ຢ່າງໃດກໍຕາມ, repacking repository ແມ່ນມີຄວາມຈໍາເປັນເພື່ອປັບປຸງສະຖານທີ່ຂໍ້ມູນແລະການເຂົ້າເຖິງ
ການປະຕິບັດ. ມັນຍັງສາມາດໃຊ້ເວລາຫຼາຍຊົ່ວໂມງໃນໂຄງການຂະຫນາດໃຫຍ່ທີ່ສຸດ (ໂດຍສະເພາະຖ້າ -f ແລະ a
ຕົວກໍານົດການ -window ຂະຫນາດໃຫຍ່ຖືກນໍາໃຊ້). ເນື່ອງຈາກວ່າ repacking ແມ່ນປອດໄພທີ່ຈະດໍາເນີນການຄຽງຄູ່ຜູ້ອ່ານແລະ
ນັກຂຽນ, ດໍາເນີນການ repack ໃນພື້ນຫລັງແລະປ່ອຍໃຫ້ມັນສໍາເລັດເມື່ອມັນສໍາເລັດ. ບໍ່ມີ
ເຫດຜົນທີ່ຕ້ອງລໍຖ້າເພື່ອສຳຫຼວດໂຄງການ Git ໃໝ່ຂອງເຈົ້າ!
ຖ້າທ່ານເລືອກທີ່ຈະລໍຖ້າການຫຸ້ມຫໍ່ຄືນໃຫມ່, ຢ່າພະຍາຍາມດໍາເນີນການມາດຕະຖານຫຼືການທົດສອບການປະຕິບັດ
ຈົນກ່ວາການຫຸ້ມຫໍ່ຄືນສໍາເລັດ. ການນໍາເຂົ້າໄວໄດ້ຮັບຜົນໄດ້ຮັບ suboptimal packs ທີ່ງ່າຍດາຍ
ບໍ່ເຄີຍເຫັນໃນສະຖານະການການນໍາໃຊ້ທີ່ແທ້ຈິງ.
ການຫຸ້ມຫໍ່ຄືນ ປະຫວັດສາດ ຂໍ້ມູນ
ຖ້າທ່ານກໍາລັງ repacking ຂໍ້ມູນທີ່ນໍາເຂົ້າເກົ່າຫຼາຍ (ເຊັ່ນ: ເກົ່າກວ່າປີທີ່ຜ່ານມາ), ພິຈາລະນາ
ໃຊ້ເວລາ CPU ພິເສດບາງຢ່າງ ແລະສະໜອງ --window=50 (ຫຼືສູງກວ່າ) ເມື່ອທ່ານແລ່ນ ໄປ
repack. ອັນນີ້ຈະໃຊ້ເວລາດົນກວ່າ, ແຕ່ຍັງຈະຜະລິດເປັນ packfile ຂະຫນາດນ້ອຍກວ່າ. ທ່ານພຽງແຕ່ຕ້ອງການ
ໃຊ້ຄວາມພະຍາຍາມຄັ້ງດຽວ, ແລະທຸກຄົນທີ່ໃຊ້ໂຄງການຂອງເຈົ້າຈະໄດ້ຮັບຜົນປະໂຫຍດຈາກຂະຫນາດນ້ອຍກວ່າ
repository
ລວມ ບາງ ຄວາມຄືບຫນ້າ ຂໍ້ຄວາມ
ທຸກໆຄັ້ງໃນຂະນະດຽວກັນໃຫ້ frontend ຂອງທ່ານສົ່ງຂໍ້ຄວາມຄວາມຄືບຫນ້າເພື່ອນໍາເຂົ້າໄວ. ໄດ້
ເນື້ອໃນຂອງຂໍ້ຄວາມແມ່ນມີຮູບແບບຟຣີທັງຫມົດ, ສະນັ້ນຄໍາແນະນໍາຫນຶ່ງທີ່ຈະໄດ້ຮັບຜົນຜະລິດໄດ້
ເດືອນປັດຈຸບັນ ແລະປີແຕ່ລະຄັ້ງທີ່ວັນທີສັນຍາປັດຈຸບັນຍ້າຍໄປໃນເດືອນຕໍ່ໄປ. ຂອງເຈົ້າ
ຜູ້ໃຊ້ຈະຮູ້ສຶກດີຂຶ້ນທີ່ຮູ້ຈັກຂອງນ້ໍາຂໍ້ມູນໄດ້ຮັບການປຸງແຕ່ງ.
PACKFILE OPTIMIZATION
ໃນເວລາທີ່ການຫຸ້ມຫໍ່ blob ໄດ້ໄວນໍາເຂົ້າສະເຫມີພະຍາຍາມ deltify ຕໍ່ກັບ blob ສຸດທ້າຍລາຍລັກອັກສອນ.
ເວັ້ນເສຍແຕ່ຈັດສະເພາະໂດຍທາງຫນ້າ, ອັນນີ້ອາດຈະບໍ່ແມ່ນກ່ອນ
ເວີຊັນຂອງໄຟລ໌ດຽວກັນ, ດັ່ງນັ້ນ delta ທີ່ສ້າງຂຶ້ນຈະບໍ່ນ້ອຍທີ່ສຸດເທົ່າທີ່ເປັນໄປໄດ້. ໄດ້
packfile ຜົນໄດ້ຮັບຈະຖືກບີບອັດ, ແຕ່ຈະບໍ່ດີທີ່ສຸດ.
Frontends ທີ່ມີການເຂົ້າເຖິງປະສິດທິພາບໃນການດັດແກ້ທັງຫມົດຂອງໄຟລ໌ດຽວ (ຕົວຢ່າງ
ອ່ານໄຟລ໌ RCS/CVS ,v) ສາມາດເລືອກສະໜອງການແກ້ໄຂທັງໝົດຂອງໄຟລ໌ນັ້ນເປັນລໍາດັບ.
ຂອງຄໍາສັ່ງ blob ຕິດຕໍ່ກັນ. ນີ້ອະນຸຍາດໃຫ້ນໍາເຂົ້າໄວເພື່ອ deltify ໄຟລ໌ທີ່ແຕກຕ່າງກັນ
ການແກ້ໄຂຕໍ່ກັນແລະກັນ, ປະຫຍັດພື້ນທີ່ໃນ packfile ສຸດທ້າຍ. ເຄື່ອງຫມາຍສາມາດຖືກນໍາໃຊ້ເພື່ອ
ຕໍ່ມາກໍານົດການແກ້ໄຂໄຟລ໌ສ່ວນບຸກຄົນໃນລະຫວ່າງລໍາດັບຄໍາສັ່ງຂອງຄໍາຫມັ້ນສັນຍາ.
packfile(s) ທີ່ສ້າງຂຶ້ນໂດຍການນໍາເຂົ້າໄວບໍ່ໄດ້ຊຸກຍູ້ໃຫ້ມີຮູບແບບການເຂົ້າເຖິງແຜ່ນທີ່ດີ. ນີ້ແມ່ນ
ທີ່ເກີດຈາກການນໍາເຂົ້າໄວຂຽນຂໍ້ມູນໃນຄໍາສັ່ງທີ່ມັນໄດ້ຮັບໃນການປ້ອນມາດຕະຖານ,
ໃນຂະນະທີ່ Git ປົກກະຕິແລ້ວຈັດລະບຽບຂໍ້ມູນພາຍໃນ packfiles ເພື່ອເຮັດໃຫ້ຫລ້າສຸດ (ຄໍາແນະນໍາໃນປະຈຸບັນ)
ຂໍ້ມູນປະກົດຂຶ້ນກ່ອນຂໍ້ມູນປະຫວັດສາດ. Git ຍັງກຸ່ມຄໍາຫມັ້ນສັນຍາຮ່ວມກັນ, ເລັ່ງ
ການແກ້ໄຂການຂ້າມຜ່ານພື້ນທີ່ແຄດທີ່ດີກວ່າ.
ສໍາລັບເຫດຜົນນີ້, ມັນແນະນໍາໃຫ້ຜູ້ໃຊ້ repack repository ກັບ git
repack -a -d ຫຼັງຈາກການນໍາເຂົ້າຢ່າງວ່ອງໄວສໍາເລັດສົມບູນ, ໃຫ້ Git ໃນການຈັດຕັ້ງໃຫມ່ຂອງ packfiles ສໍາລັບການ
ການເຂົ້າເຖິງຂໍ້ມູນໄວຂຶ້ນ. ຖ້າ blob deltas ແມ່ນດີທີ່ສຸດ (ເບິ່ງຂ້າງເທິງ) ຫຼັງຈາກນັ້ນກໍ່ເພີ່ມ -f
ທາງເລືອກທີ່ຈະບັງຄັບໃຫ້ recomputation ຂອງ deltas ທັງຫມົດສາມາດຫຼຸດລົງຢ່າງຫຼວງຫຼາຍ packfile ສຸດທ້າຍ
ຂະຫນາດ (30-50% ຂະຫນາດນ້ອຍສາມາດຂ້ອນຂ້າງປົກກະຕິ).
ຫນ່ວຍຄວາມຈໍາ ການນໍາໃຊ້
ມີປັດໃຈຈໍານວນຫນຶ່ງທີ່ສົ່ງຜົນກະທົບຕໍ່ການນໍາເຂົ້າຄວາມຈໍາໄວຫຼາຍປານໃດເພື່ອປະຕິບັດ
ການນໍາເຂົ້າ. ເຊັ່ນດຽວກັນກັບພາກສ່ວນທີ່ສໍາຄັນຂອງ Git ຫຼັກ, ການນໍາເຂົ້າໄວໃຊ້ຕົວຈັດສັນຫນ່ວຍຄວາມຈໍາຂອງຕົນເອງ
ເພື່ອຫຼຸດຄ່າໃຊ້ຈ່າຍໃດໆທີ່ກ່ຽວຂ້ອງກັບ malloc. ໃນການປະຕິບັດການນໍາເຂົ້າໄວມັກຈະມີແນວໂນ້ມທີ່ຈະ
amortize any malloc overheads ເປັນ 0, ເນື່ອງຈາກການນໍາໃຊ້ການຈັດສັນ block ຂະຫນາດໃຫຍ່.
ຕໍ່ ຈຸດປະສົງ
fast-import ຮັກສາໂຄງສ້າງໃນຫນ່ວຍຄວາມຈໍາສໍາລັບທຸກໆວັດຖຸທີ່ຂຽນໃນການປະຕິບັດນີ້.
ໃນລະບົບ 32 bit ໂຄງສ້າງແມ່ນ 32 bytes, ໃນລະບົບ 64 bit ໂຄງສ້າງແມ່ນ 40 bytes.
(ເນື່ອງຈາກຂະຫນາດຕົວຊີ້ໃຫຍ່ກວ່າ). ວັດຖຸໃນຕາຕະລາງບໍ່ໄດ້ deallocation ຈົນກ່ວາ
ຢຸດການນໍາເຂົ້າຢ່າງໄວວາ. ການນໍາເຂົ້າວັດຖຸ 2 ລ້ານອັນໃນລະບົບ 32 ບິດຈະຕ້ອງການ
ປະມານ 64 MiB ຂອງຫນ່ວຍຄວາມຈໍາ.
ຕາຕະລາງວັດຖຸແມ່ນຕົວຈິງແລ້ວເປັນ hashtable keyed ໃນຊື່ວັດຖຸ (ສະເພາະ SHA-1). ນີ້
ການຕັ້ງຄ່າການເກັບຮັກສາອະນຸຍາດໃຫ້ນໍາເຂົ້າໄວເພື່ອນໍາມາໃຊ້ວັດຖຸທີ່ມີຢູ່ແລ້ວຫຼືຂຽນແລ້ວໃຫມ່
ແລະຫຼີກເວັ້ນການຂຽນຊໍ້າກັນໃສ່ packfile ຜົນຜະລິດ. blobs ຊ້ໍາກັນແມ່ນເປັນເລື່ອງແປກທີ່
ທົ່ວໄປໃນການນໍາເຂົ້າ, ໂດຍປົກກະຕິແມ່ນເນື່ອງມາຈາກການລວມສາຂາໃນແຫຼ່ງ.
ຕໍ່ ເຄື່ອງຫມາຍ
ເຄື່ອງຫມາຍຖືກເກັບໄວ້ໃນ array sparse, ໂດຍໃຊ້ 1 pointer (4 bytes ຫຼື 8 bytes, ຂຶ້ນກັບ.
ຂະຫນາດຕົວຊີ້) ຕໍ່ເຄື່ອງຫມາຍ. ເຖິງແມ່ນວ່າ array ແມ່ນ sparse, frontends ຍັງແຂງແຮງ
ຊຸກຍູ້ໃຫ້ໃຊ້ເຄື່ອງຫມາຍລະຫວ່າງ 1 ແລະ n, ບ່ອນທີ່ n ແມ່ນຈໍານວນເຄື່ອງຫມາຍທັງຫມົດທີ່ຕ້ອງການ
ການນໍາເຂົ້ານີ້.
ຕໍ່ ສາຂາ
ສາຂາຖືກຈັດປະເພດເປັນການເຄື່ອນໄຫວແລະບໍ່ເຄື່ອນໄຫວ. ການນໍາໃຊ້ຄວາມຊົງຈໍາຂອງສອງຫ້ອງຮຽນແມ່ນ
ແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍ.
ສາຂາທີ່ບໍ່ເຄື່ອນໄຫວຖືກເກັບໄວ້ໃນໂຄງສ້າງທີ່ໃຊ້ 96 ຫຼື 120 ໄບຕ໌ (32 ບິດ ຫຼື 64 ບິດ.
ລະບົບ, ຕາມລໍາດັບ), ບວກກັບຄວາມຍາວຂອງຊື່ສາຂາ (ປົກກະຕິພາຍໃຕ້ 200 bytes),
ຕໍ່ສາຂາ. ການນໍາເຂົ້າໄວຈະຈັດການຢ່າງງ່າຍດາຍເປັນ 10,000 ສາຂາທີ່ບໍ່ມີການເຄື່ອນໄຫວພາຍໃຕ້ການ 2
MiB ຂອງຫນ່ວຍຄວາມຈໍາ.
ສາຂາທີ່ໃຊ້ວຽກມີສ່ວນເທິງຄືກັບສາຂາທີ່ບໍ່ເຄື່ອນໄຫວ, ແຕ່ຍັງມີສຳເນົາຂອງ
ຕົ້ນໄມ້ທຸກຕົ້ນທີ່ໄດ້ຖືກດັດແປງເມື່ອບໍ່ດົນມານີ້ຢູ່ໃນສາຂານັ້ນ. ຖ້າຫາກວ່າ subtree ລວມບໍ່ໄດ້
ດັດແກ້ນັບຕັ້ງແຕ່ສາຂາໄດ້ກາຍເປັນການເຄື່ອນໄຫວ, ເນື້ອໃນຂອງມັນຈະບໍ່ຖືກໂຫລດເຂົ້າໄປໃນຫນ່ວຍຄວາມຈໍາ, ແຕ່
ຖ້າ subtree src ໄດ້ຖືກດັດແກ້ໂດຍຄໍາຫມັ້ນສັນຍານັບຕັ້ງແຕ່ສາຂາໄດ້ກາຍເປັນການເຄື່ອນໄຫວ, ຫຼັງຈາກນັ້ນຂອງມັນ
ເນື້ອຫາຈະຖືກໂຫລດຢູ່ໃນຫນ່ວຍຄວາມຈໍາ.
ໃນຖານະເປັນສາຂາທີ່ເຄື່ອນໄຫວເກັບຮັກສາ metadata ກ່ຽວກັບໄຟລ໌ທີ່ມີຢູ່ໃນສາຂານັ້ນ, ຂອງມັນ
ຂະໜາດບ່ອນເກັບຂໍ້ມູນໃນໜ່ວຍຄວາມຈຳສາມາດຂະຫຍາຍເປັນຂະໜາດທີ່ພໍສົມຄວນ (ເບິ່ງຂ້າງລຸ່ມນີ້).
fast-import ອັດຕະໂນມັດຍ້າຍສາຂາທີ່ເຄື່ອນໄຫວໄປສູ່ສະຖານະທີ່ບໍ່ເຄື່ອນໄຫວໂດຍອີງໃສ່ແບບງ່າຍດາຍ
algorithm ທີ່ຫາກໍ່ໃຊ້ໜ້ອຍທີ່ສຸດ. ລະບົບຕ່ອງໂສ້ LRU ໄດ້ຖືກປັບປຸງໃນແຕ່ລະຄໍາສັ່ງ commit. ໄດ້
ຈໍານວນສູງສຸດຂອງສາຂາການເຄື່ອນໄຫວສາມາດໄດ້ຮັບການເພີ່ມຂຶ້ນຫຼືຫຼຸດລົງໃນບັນຊີຄໍາສັ່ງທີ່ມີ
--active-ສາຂາ=.
ຕໍ່ ການເຄື່ອນໄຫວ ເປັນໄມ້ຢືນຕົ້ນ
Trees (aka directories) ໃຊ້ພຽງແຕ່ 12 bytes ຂອງຫນ່ວຍຄວາມຈໍາຢູ່ເທິງສຸດຂອງຫນ່ວຍຄວາມຈໍາທີ່ຕ້ອງການ
ລາຍການຂອງເຂົາເຈົ້າ (ເບິ່ງ “ຕໍ່ໄຟລ໌ທີ່ມີການເຄື່ອນໄຫວ” ຂ້າງລຸ່ມນີ້). ຄ່າໃຊ້ຈ່າຍຂອງຕົ້ນໄມ້ແມ່ນເກືອບ 0, ເປັນຂອງມັນ
overhead amortizes ອອກໃນໄລຍະແຕ່ລະລາຍການໄຟລ໌.
ຕໍ່ ການເຄື່ອນໄຫວ ເອກະສານ entry
ໄຟລ໌ (ແລະຊີ້ໄປຫາຕົ້ນໄມ້ຍ່ອຍ) ພາຍໃນຕົ້ນໄມ້ທີ່ໃຊ້ວຽກຕ້ອງການ 52 ຫຼື 64 bytes (32/64 bits
platforms) ຕໍ່ລາຍການ. ເພື່ອອະນຸລັກພື້ນທີ່, ໄຟລ໌ ແລະຊື່ຕົ້ນໄມ້ຖືກລວມຢູ່ໃນສະຕຣິງທົ່ວໄປ
ຕາຕະລາງ, ອະນຸຍາດໃຫ້ຊື່ໄຟລ໌ "Makefile" ໃຊ້ພຽງແຕ່ 16 ໄບຕ໌ (ຫຼັງຈາກລວມເຖິງສະຕຣິງ
header overhead) ບໍ່ວ່າມັນຈະເກີດຂຶ້ນພາຍໃນໂຄງການຫຼາຍປານໃດ.
ສາຂາທີ່ເຄື່ອນໄຫວ LRU, ເມື່ອສົມທົບກັບສະຕຣິງຊື່ໄຟລ໌ແລະການໂຫຼດທີ່ຂີ້ກຽດ
ຕົ້ນໄມ້ຍ່ອຍ, ອະນຸຍາດໃຫ້ການນໍາເຂົ້າໄວເພື່ອປະສິດທິຜົນການນໍາເຂົ້າໂຄງການທີ່ມີ 2,000+ ສາຂາແລະ
45,114+ ໄຟລ໌ໃນຄວາມຈຳທີ່ຈຳກັດຫຼາຍ (ໜ້ອຍກວ່າ 2.7 MiB ຕໍ່ສາຂາທີ່ໃຊ້ໄດ້).
ລາຍເຊັນ
ການສົ່ງອອກ SIGUSR1 ການ ໄປ ການນໍາເຂົ້າໄວ ຂະບວນການສິ້ນສຸດ packfile ປະຈຸບັນຕົ້ນ, simulating
ຄໍາສັ່ງດ່ານ. ຜູ້ປະຕິບັດການທີ່ບໍ່ອົດທົນສາມາດໃຊ້ສິ່ງອໍານວຍຄວາມສະດວກນີ້ເພື່ອແນມເບິ່ງວັດຖຸຕ່າງໆ
ແລະອ້າງອີງຈາກການນໍາເຂົ້າທີ່ກໍາລັງດໍາເນີນຢູ່, ໃນຄ່າໃຊ້ຈ່າຍຂອງບາງເວລາແລ່ນເພີ່ມຂຶ້ນແລະຮ້າຍແຮງກວ່າເກົ່າ
ການບີບອັດ.
ໃຊ້ git-fast-import ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
