Git Branch: Git యొక్క తేలికైన pointer వ్యవస్థ లోపల ఎలా పనిచేస్తుంది

సంక్షిప్తంగా: Git లో branch అంటే మీ source files కి folder copy లేదా భారీ snapshot కాదు. Git యొక్క డిఫాల్ట్ files reference format లో, అది కేవలం తేలికైన, మార్చగల reference — 40 అక్షరాల commit SHA-1 hash, దాని తర్వాత newline character కలిపి మొత్తం 41-byte text file — ఇది .git/refs/heads/ directory లో నిల్వ ఉంటుంది. అందుకే Git లో branches సృష్టించడం, పేరు మార్చడం లేదా తొలగించడం దాదాపు వెంటనే పూర్తవుతుంది: working directory లోని files ను మార్చడం లేదా copy చేయడం కాకుండా, ఈ reference files ను మాత్రమే మార్చుతుంది.

పరిధి గమనిక: ఈ పేజీలోని “41-byte file” వివరణ Git యొక్క డిఫాల్ట్ files reference backend లో branch unpacked గా ఉన్నప్పుడు మాత్రమే ఖచ్చితంగా వర్తిస్తుంది. git gc ద్వారా references ను .git/packed-refs లో pack చేయవచ్చు. అలాగే Git లో alternative reftable backend కూడా ఉంది; అందులో branches ఒక్కొక్కటి files గా ఉండవు. ఏ సందర్భంలోనైనా commands, behaviour ఒకటే — disk పై representation మాత్రమే మారుతుంది. వివరాలకు Git Refs చూడండి.

branch అనేది మీ files copy కాదు, ఒక ref

Git branching model ఎందుకు ఇంత ప్రభావవంతంగా ఉందో అర్థం చేసుకోవాలంటే, దాన్ని పాత Version Control Systems (VCS) అయిన Subversion (SVN), Perforce లతో పోల్చడం ఉపయోగకరం. ఆ పాత systems లో branch సృష్టించడం అంటే మొత్తం project directory tree కి physical copy చేయడం. మీ codebase 5 GB అయితే, branch సృష్టించడానికి server పై 5 GB files copy చేయాల్సి వచ్చేది. దీనికి చాలా సమయం పట్టేది, disk space వృథా అయ్యేది; చిన్న పనుల కోసం కూడా branches సృష్టించేందుకు developers వెనుకాడేవారు.

Git files ను copy చేయదు. బదులుగా, Git మీ project history ని commit objects తో కూడిన Directed Acyclic Graph (DAG) గా నిర్వహిస్తుంది. ప్రతి commit తన parent commit(s) ను సూచిస్తుంది; దీంతో history tree లాంటి structure గా ఏర్పడుతుంది. ఈ graph లో:

• Commit అనేది ఒక నిర్దిష్ట సమయంలో మీ project లోని tracked files యొక్క snapshot, దానికి author metadata, parent links కూడా ఉంటాయి. commit object structure వివరాలకు /git-commit చూడండి.
• Branch అనేది ఈ graph లోని ఒక నిర్దిష్ట commit వైపు చూపే named reference మాత్రమే. ఆ branch history ని నిర్మించడానికి parent pointers ద్వారా వెనక్కి వెళ్లే ప్రారంభ బిందువు అది.

Branch ను commits chain లోని ఒక నిర్దిష్ట node కు అంటించిన sticky note లాగా ఊహించండి. మీరు active branch పై పని చేసి కొత్త commits సృష్టిస్తే, తాజా commit వైపు చూపేలా Git ఆ sticky note ను ఆటోమేటిక్‌గా ముందుకు జరుపుతుంది. Branch ఒక reference (లేదా “ref”) మాత్రమే కాబట్టి, Git branching operations కు చిన్న 40-character string ను రాయడం లేదా మార్చడం చాలు.

Git యొక్క సాధారణ reference system గురించి మరింత లోతుగా తెలుసుకోవడానికి /git-refs guide చదవండి.

మూడు రెఫరెన్స్‌లను గందరగోళపరచుకోవడం సులభం: refs/heads/main మీ స్థానిక బ్రాంచ్; refs/remotes/origin/main రిమోట్ బ్రాంచ్ యొక్క మీ స్థానిక రికార్డ్, దీన్ని git fetch వంటి కమాండ్లు అప్‌డేట్ చేస్తాయి; మరియు HEAD ప్రస్తుతం చెక్అవుట్ చేసిన బ్రాంచ్‌ను లేదా detached-HEAD స్థితిలో నేరుగా ఒక కమిట్‌ను సూచిస్తుంది. విజయవంతమైన git push కూడా సంబంధిత రిమోట్-ట్రాకింగ్ రెఫ్‌ను అప్‌డేట్ చేయవచ్చు.

మీరు branch చేస్తుండగా refs/heads ఎలా మారుతుందో చూడండి

Git branches ఎలా పనిచేస్తాయో పూర్తిగా అర్థం చేసుకోవడానికి, terminal walkthrough ను దశలవారీగా చేసి, branching operations సమయంలో .git/ directory ఎలా మారుతుందో చూద్దాం.

దశ 1: ఖాళీ repository ని ప్రారంభించడం

కొత్త repository సృష్టించి, ఒక commit చేసి, .git/ directory structure ను చూద్దాం.

$ mkdir git-branch-demo
$ cd git-branch-demo
$ git init
Initialized empty Git repository in /users/admin/git-branch-demo/.git/

ఈ దశలో .git/refs/heads/ లోని contents ను list చేస్తే అది పూర్తిగా ఖాళీగా ఉంటుంది:

$ ls -la .git/refs/heads/
total 0
drwxr-xr-x  2 admin  staff  64 Jul  7 10:25 .
drwxr-xr-x  4 admin  staff 128 Jul  7 10:25 ..

ఇంకా commits ఏవీ లేవు కాబట్టి default branch file సృష్టించబడలేదు. .git/HEAD ఎటు చూపుతుందో చూద్దాం:

$ cat .git/HEAD
ref: refs/heads/main

refs/heads/main ఇంకా disk పై లేకపోయినా, HEAD దానివైపు చూపేలా ముందుగానే సిద్ధంగా ఉంది. ఈ స్థితిని “unborn branch” అంటారు. ఇప్పుడు మొదటి commit చేసి branch ను ఉనికిలోకి తెద్దాం.

$ echo "Hello Git Branching!" > README.md
$ git add README.md
$ git commit -m "Initial commit"
[main (root-commit) f24e93e] Initial commit
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

ఇప్పుడు commit ఉన్నందున .git/refs/heads/ ను మళ్లీ పరిశీలిద్దాం:

$ ls -la .git/refs/heads/
total 8
drwxr-xr-x  3 admin  staff   96 Jul  7 10:27 .
drwxr-xr-x  4 admin  staff  128 Jul  7 10:25 ..
-rw-r--r--  1 admin  staff   41 Jul  7 10:27 main

main అనే file కనిపించింది! ఆ file contents ను print చేద్దాం:

$ cat .git/refs/heads/main
f24e93e25b90f46c6a7e0c4a45adbb474f8e6c7c

ఈ file లో newline character తర్వాత ఖచ్చితంగా 40-character SHA-1 commit hash ఉంది. ఈ hash ఏదిని సూచిస్తుందో plumbing command git cat-file తో ధృవీకరిద్దాం:

$ git cat-file -t f24e93e25b90f46c6a7e0c4a45adbb474f8e6c7c
commit

మన snapshot ను commit object ఎలా సూచిస్తుందో చూడటానికి దాని contents ను print చేద్దాం:

$ git cat-file -p f24e93e25b90f46c6a7e0c4a45adbb474f8e6c7c
tree 5b38a7c29375ab2b4a53239a584a22c5432a138b
author User <user@example.com> 1783420000 +0000
committer User <user@example.com> 1783420000 +0000

Initial commit

దశ 2: కొత్త branch సృష్టించడం

ఇప్పుడు git branch command తో feature-login అనే కొత్త branch ను సృష్టిద్దాం:

$ git branch feature-login

లోపల Git ఏం చేసిందో చూడటానికి .git/refs/heads/ contents ను పరిశీలిద్దాం:

$ ls -la .git/refs/heads/
total 16
drwxr-xr-x  4 admin  staff  128 Jul  7 10:30 .
drwxr-xr-x  4 admin  staff  128 Jul  7 10:25 ..
-rw-r--r--  1 admin  staff   41 Jul  7 10:30 feature-login
-rw-r--r--  1 admin  staff   41 Jul  7 10:27 main

feature-login అనే కొత్త file సృష్టించబడింది. దాని contents చదుద్దాం:

$ cat .git/refs/heads/feature-login
f24e93e25b90f46c6a7e0c4a45adbb474f8e6c7c

ఇందులో main లో ఉన్నదే అదే commit hash ఉంది! Git source files ను copy చేయలేదు. ఇప్పటికే ఉన్న commit ను చూపే 41-byte text file ను మాత్రమే సృష్టించింది (డిఫాల్ట్ unpacked files reference format అనుకుంటే). అందుకే branch creation వెంటనే పూర్తవుతుంది.

.git/HEAD చదివి మన active branch ను పరిశీలిద్దాం:

$ cat .git/HEAD
ref: refs/heads/main

HEAD ఇంకా main వైపు చూపుతోంది; అంటే మనం ఇప్పటికీ main branch పై ఉన్నాం. Branch మార్చడానికి HEAD reference ను update చేయాలి; సాధారణంగా git checkout లేదా git switch వంటి commands దీన్ని నిర్వహిస్తాయి. ఈ mechanism గురించి /git-checkout లో మరింత చదవండి.

దశ 3: branch పై commit చేయడం

ఇప్పుడు కొత్త branch కు మారి ఒక మార్పు చేద్దాం.

$ git checkout feature-login
Switched to branch 'feature-login'

ఇప్పుడు .git/HEAD ను ధృవీకరిద్దాం:

$ cat .git/HEAD
ref: refs/heads/feature-login

HEAD ఇప్పుడు refs/heads/feature-login వైపు చూపేలా update అయింది. ఒక కొత్త commit చేద్దాం:

$ echo "Login Form UI" > login.html
$ git add login.html
$ git commit -m "Add login page"
[feature-login a7c8e9d] Add login page
 1 file changed, 1 insertion(+)
 create mode 100644 login.html

ఇప్పుడు మన branch references contents ను చూద్దాం:

$ cat .git/refs/heads/feature-login
a7c8e9d8928424ef245eefb925b42d3851b2c129

$ cat .git/refs/heads/main
f24e93e25b90f46c6a7e0c4a45adbb474f8e6c7c

feature-login ముందుకు కదిలి కొత్త commit a7c8e9d... వైపు చూపుతోంది. అయితే main మాత్రం f24e93e... వైపే ఉంది. /git-log తో history పరిశీలిస్తే:

$ git log --oneline --graph --all
* a7c8e9d (HEAD -> feature-login) Add login page
* f24e93e (main) Initial commit

feature-login branch విడిపోయిందని graph చూపుతోంది. main branch pointer స్థిరంగా ఉంది; feature-login మాత్రం HEAD తో పాటు ముందుకు కదిలింది. తర్వాత ఈ branches ను merge చేయాలనుకుంటే, వాటి histories లెక్కించడానికి Git ఈ pointers ను చదువుతుంది. దీని గురించి /git-merge లో తెలుసుకోండి.

Branches సృష్టించడం, పేరు మార్చడం, తొలగించడం

git branch command references సృష్టించడానికి మాత్రమే కాదు; branch graph ను manage చేయడానికి, query చేయడానికి, audit చేయడానికి కూడా ఉపయోగపడే versatile tool.

1. Branches జాబితా చేయడం, ఫిల్టర్ చేయడం

పెద్ద projects నిర్వహించేటప్పుడు local, remote branches డజన్లకొద్దీ ఉండవచ్చు. వాటిని సక్రమంగా ఉంచేందుకు Git filters అందిస్తుంది.

• అన్ని branches (local, remote) list చేయడం:

  $ git branch -a

  ఇది local branches ను ఒక రంగులో (ఉదా., green), .git/refs/remotes/ లో నిల్వ ఉన్న remote-tracking branches ను మరో రంగులో (ఉదా., red) చూపిస్తుంది.
• Merge status ఆధారంగా filter చేయడం: పాత branches తొలగించే ముందు, ప్రస్తుత branch లోకి ఏ branches సురక్షితంగా merge అయ్యాయో తెలుసుకోవాలి:

  $ git branch --merged

  ప్రస్తుత branch లోకి ఇంకా merge కాని work ఉన్న branches చూడటానికి:

  $ git branch --no-merged

  --no-merged జాబితాలోని ఏ branch పై అయినా git branch -d నడిపితే, force చేయనంతవరకు అది విఫలమవుతుంది.
• Upstream tracking తో verbose listing:

  $ git branch -vv

  ఇది latest commit hash, commit subject line, upstream tracking status (ఉదా., మీ local branch దాని remote counterpart కంటే ahead లేదా behind లో ఉందా) చూపిస్తుంది.

2. డిలీషన్ లోపలి పని, గార్బేజ్ కలెక్షన్

Branch తొలగించడం సాధారణ పని, అయితే ఉపయోగించే flags ఆధారంగా అది వేర్వేరుగా పనిచేస్తుంది.

• సురక్షితంగా తొలగించడం (-d లేదా --delete):

  $ git branch -d feature-login

  ప్రస్తుత branch లేదా upstream branch నుంచి reach కాని commits ఉన్న branch ను తొలగించకుండా Git ఆపుతుంది. ఇలా అనుకోకుండా work పోకుండా కాపాడుతుంది.
• బలవంతంగా తొలగించడం (-D లేదా -d --force):

  $ git branch -D feature-login

  “ఏదైనా సరే reference ను తొలగించు” అని ఇది Git కు చెబుతుంది.

Commits కు ఏమవుతుంది?

బ్రాంచ్‌ను తొలగించడం దాని రెఫ్‌ను తొలగిస్తుంది; కమిట్ ఆబ్జెక్ట్‌లను వెంటనే తుడిచివేయదు. ఆ కమిట్‌లను చేరుకునే మరో రెఫ్ లేకపోతే, అవి unreachable అవుతాయి మరియు కొంతకాలం reflog ద్వారా పునరుద్ధరించబడవచ్చు. Git చివరికి unreachable ఆబ్జెక్ట్‌లను prune చేయవచ్చు; దీని సమయం కాన్ఫిగరేషన్ మరియు రిపాజిటరీ స్థితిపై ఆధారపడి ఉంటుంది. పని ముఖ్యమైనది అయితే, శుభ్రపరచడానికి ముందు మరో బ్రాంచ్ సృష్టించండి; ఆబ్జెక్ట్ జీవితచక్రం కోసం Git objects చూడండి.

3. Upstream branches ట్రాక్ చేయడం

Collaboration సమయంలో మీ local branches remote server (ఉదా., GitHub) లోని branches ను track చేస్తాయి. ఈ tracking configuration .git/config లో నిల్వ ఉంటుంది.

ప్రస్తుత active branch కు upstream branch set చేయడానికి:

$ git branch -u origin/feature-login
# Or:
$ git branch --set-upstream-to=origin/feature-login

ఇది మీ .git/config file లో tracking metadata ను చేర్చుతుంది:

[branch "feature-login"]
    remote = origin
    merge = refs/heads/feature-login

ఈ configuration వల్ల remote, branch పేరు చెప్పకుండానే git pull లేదా git push అని సులభంగా టైప్ చేయవచ్చు.

పొరపాటున తొలగించిన branch ను తిరిగి పొందడం

మీ workspace ను clean up చేస్తున్నారని ఊహించండి. feature-payment branch ను main లో merge చేశామని అనుకుని ఇలా నడిపారు:

$ git branch -D feature-payment
Deleted branch feature-payment (was c3b91a2).

అకస్మాత్తుగా feature-payment merge కాలేదని, రోజుల పని ఇప్పుడే delete చేశామని గుర్తొచ్చింది! Editor లో files ఇక కనిపించకపోవడంతో ఇది పెద్ద ప్రమాదంలా అనిపిస్తుంది.

దాన్ని తిరిగి పొందడం ఎలా:

Git branches references మాత్రమే కాబట్టి, commits ఇంకా database లోనే ఉంటాయి. Commit hash ను కనుగొని, దానికి కొత్త branch reference ను జతచేయాలి.

1. Reflog లో వెతకండి: HEAD స్థానం మారిన ప్రతిసారీ reflog record చేస్తుంది. దీన్ని నడపండి:

   $ git reflog
   f24e93e HEAD@{0}: checkout: moving from feature-payment to main
   c3b91a2 HEAD@{1}: commit: Add Stripe Integration and webhooks
   f24e93e HEAD@{2}: checkout: moving from main to feature-payment

   జాగ్రత్తగా చూస్తే, main కు తిరిగి మారే ముందు feature-payment branch పై చేసిన commit c3b91a2 అని తెలుస్తుంది.
2. Branch pointer ను మళ్లీ సృష్టించండి: ఇప్పుడు git branch తర్వాత కొత్త branch పేరు, మీరు తిరిగి పొందిన hash ఇవ్వండి:

   $ git branch feature-payment c3b91a2

   అంతే! Git .git/refs/heads/feature-payment వద్ద c3b91a2 ఉన్న కొత్త reference file సృష్టించి, మీ work ను వెంటనే పునరుద్ధరిస్తుంది.

Branch commands ఎక్కడ తప్పుతాయి

1. git branch కొత్త branch కు మారుతుందని అనుకోవడం

git branch new-feature నడిపితే pointer మాత్రమే సృష్టించబడుతుంది. HEAD update కాదు. వెంటనే files edit చేయడం మొదలుపెడితే, commits పాత branch (ఉదా., main) లోనే చేరతాయి. ఎప్పుడూ git checkout new-feature నడపాలని గుర్తుంచుకోండి (లేదా ఒకే దశలో create చేసి switch చేయడానికి git checkout -b new-feature ఉపయోగించండి).

2. నేమ్‌స్పేస్ ఘర్షణలు (File vs Directory)

Git branch refs ను .git/refs/heads/ లో files గా నిల్వ చేస్తుంది కాబట్టి, అవి మీ Operating System file path rules ను పాటించాలి.

• feature అనే branch ఉంటే, Git .git/refs/heads/feature అనే file సృష్టిస్తుంది.
• తర్వాత feature/login అనే branch సృష్టించాలంటే, Git feature అనే directory సృష్టించి, దాని లోపల login అనే file పెట్టాలి.
• చాలా systems లో ఒకే parent folder లో exact same name తో file, directory రెండూ ఉండలేవు. అందువల్ల ఈ error వస్తుంది: error: cannot lock ref 'refs/heads/feature/login': 'refs/heads/feature' exists; cannot create 'refs/heads/feature/login'
• పరిష్కారం: feature/login, feature/payment వంటి slash namespaces వాడాలని భావిస్తే, feature అనే generic branch ను సృష్టించవద్దు.

3. తొలగించిన remote branchesకు పాత local references

Teammate remote server లో branch delete చేసినా, మీ local Git దాన్ని .git/refs/remotes/origin/ లో ఇంకా ఉంచుతుంది. దీనివల్ల గందరగోళం రావచ్చు.

• పరిష్కారం: ఈ command తో stale remote-tracking branches ను clean up చేయండి:

  $ git fetch --prune

Branch కమాండ్లు ఒక చూపులో

Branch గురించి ప్రశ్నలకు సమాధానాలు

“detached HEAD” అంటే ఏమిటి?

HEAD named branch reference కు బదులుగా నేరుగా ఒక నిర్దిష్ట commit hash వైపు చూపుతున్నప్పుడు “detached HEAD” state ఏర్పడుతుంది. ఉదాహరణకు, .git/HEADలో ref: refs/heads/mainకు బదులుగా కమిట్ ID ఉండవచ్చు. ఈ స్థితిలో చేసిన కమిట్ ఏ బ్రాంచ్‌పైనా ఉండదు; వేరే చోటికి మారిన తర్వాత అది పేరున్న రెఫ్‌ల నుంచి unreachable కావచ్చు, అయితే reflog దాన్ని పునరుద్ధరించడంలో సహాయపడవచ్చు. పనిని నిలుపుకోవాలంటే, అదే కమిట్‌పై ఉండగానే git switch -c rescue-workతో బ్రాంచ్ సృష్టించండి. HEAD మరియు బ్రాంచ్ రెఫ్‌ల సంబంధం కోసం Git refs చూడండి.

రెండు branches ఒకే commit వైపు చూపగలవా?

అవును. అనేక branches ఒకే commit hash వైపు చూపగలవు. వాస్తవానికి, main నుంచి కొత్త branch సృష్టించినప్పుడు, వాటిలో ఒకదానిపై కొత్త commit చేసే వరకు రెండు branches ఒకే commit వైపు చూపుతాయి. ఒకే 40-character SHA-1 string ఉన్న అనేక refs తో Git కు ఎలాంటి సమస్య ఉండదు.

Local branchను remote serverకు ఎలా push చేయాలి?

మీ branch ను remote repository కు push చేసి, అది ఆ remote ను track చేసేలా చేయడానికి ఈ command ఉపయోగించండి:

$ git push -u origin <branch-name>

-u (లేదా --set-upstream) flag tracking association ను సృష్టించమని Git కు చెబుతుంది. ఇది మీ .git/config file ను update చేస్తుంది; దాంతో ఈ branch పై తర్వాత pushes, pulls కు git push లేదా git pull మాత్రమే సరిపోతాయి.

మీ అవగాహనను పరీక్షించుకోండి