# डाटा- लाइब्रेरी: ईएफ कोर तथा एसक्यूएल (ऊपर- व्यू) के साथ थर्मिभाषिक डाटा को समायोजित कर रहा है

<!--category-- Entity Framework, PostgreSQL, EF Hierarchies -->
<datetime class="hidden">2025-12-06T09:00</datetime>

## परिचय

"मैं एक संबंध डाटाबेस में वृक्ष जमा कैसे करता हूँ?" एसक्यूएल, और स्पष्ट रूप से, वहाँ अभी भी कोई भी जवाब बनाता है कि मैं सभी को खुश बनाता हूँ. [पहले ने 2004 में इस विषय के बारे में लिखा](/blog/1188), और आज की बुनियादी चुनौतियों का भी यही हाल है ।

### एसक्यूएल में जमा होना क्यों मुश्‍किल है

यहाँ बुनियादी समस्या है: **संबंधता डाटाबेस सेट में सोचते हैं, पेड़ नहीं**जो कोलको अपनी बेहतरीन किताब में समझाता है [सेट में सोचना](https://www.amazon.com/Joe-Celkos-Thinking-Sets-Management/dp/0123741378)एसक्यूएल पूरी तालिका पर काम करता है न कि हर पंक्‍ति पर ।

जब आप एसक्यूएल क्वैरी लिखते हैं, डाटाबेस इंजिन चालू करता है *पंक्तियों के सेट*" 100 से अधिक" या "अपने खरीदने के लिए ग्राहकों" - इन ऑपरेशनों में स्वाभाविक रूप से कैसे मेज के काम के साथ फिट हैं। परिणाम हमेशा पंक्ति का एक समतल सेट है।

लेकिन एक वर्ग स्वाभाविक रूप से है *रिकर्सिव*.. एक नोड के सभी बच्चों को खोजने के लिए, आप की जरूरत है:

1. तत्काल बच्चों को ढूंढें
2. प्रत्येक बच्चे के लिए, पाते हैं *उनकी* शिशु
3. जब तक आप पूरे सब ट्री का दौरा कर चुके हैं दोहराएँ

यह पुनरावर्तन ऑपरेशन सेट करने के लिए स्वाभाविक रूप से मैप नहीं करता है. आप "मुझे किसी भी गहराई में सभी बच्चों को दे" नहीं कर सकते हैं, बिना भी या तो सरल एसक्यूएल कथन:

- [रिकर्सिव सीटीई](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-RECURSIVE) ( एसक्यूएल: १९९८9 में जोड़ दिया, लेकिन गणनाात्मक रूप से लागत)
- डाटाबेस में अनेक दौर यात्रा
- सामान्यीकरण कि रिश्‍तों को अलग करता है

इस श्रंखला में हर तरीका एक अलग व्यापार के बारे में बताता है जो जटिल लिखना, जटिल और भंडारण के बीच है। वहाँ कोई मुफ्त भोजन - आप हमेशा एक दूसरे के लिए व्यापार कर रहे हैं। इस विषय पर अटल संदर्भ के लिए, जो सीएलको के बारे में देखें। [एसक्यूएल में मुसलमानों के लिए पेड़ और हायरों](https://www.amazon.com/Hierarchies-Smarties-Kaufmann-Management-Systems/dp/0123877334), जो इन सभी के पास गहराई में है।

[TOC]

## उदाहरण: लड़ी गई टिप्पणी

तुलना स्पष्ट बनाने के लिए, हम अपने चल रहे उदाहरण के रूप में अपनी टिप्पणी का उपयोग करेंगे - यह बहुत ही ब्लॉग उपयोग करता है। एक टिप्पणी थ्रेड इस तरह लग सकता है:

```mermaid
flowchart TD
    subgraph Post["Post: How to Deploy Docker Containers"]
        C1["Comment 1: Great article!<br/>depth 0"]
        C2["Comment 2: Thanks!<br/>depth 1"]
        C3["Comment 3: Very helpful indeed<br/>depth 1"]
        C4["Comment 4: Agreed!<br/>depth 2"]
        C5["Comment 5: What about Kubernetes?<br/>depth 0"]
        C6["Comment 6: That's covered in part 2<br/>depth 1"]
    end

    C1 --> C2
    C1 --> C3
    C3 --> C4
    C5 --> C6

    style Post stroke:#10b981,stroke-width:2px
    style C1 stroke:#6366f1,stroke-width:2px
    style C2 stroke:#8b5cf6,stroke-width:2px
    style C3 stroke:#8b5cf6,stroke-width:2px
    style C4 stroke:#a855f7,stroke-width:2px
    style C5 stroke:#6366f1,stroke-width:2px
    style C6 stroke:#8b5cf6,stroke-width:2px
```

हमें इन ऑपरेशनों को समर्थन देने की आवश्यकता है:

- **पोस्ट के लिए सभी टिप्पणियाँ लें** ( थ्रेडिंग स्ट्रक्चर के साथ सुरक्षित)
- **सभी पूर्वज प्राप्त करें** टिप्पणी का (कब्लिकल ट्रे)
- **सभी वंशज लाएँ** टिप्पणी का (रूट सब ट्री)
- **नया टिप्पणी जोड़ें** (एक मौजूदा टिप्पणी के लिए जवाब दें)
- **सब ट्री मिटाएँ** (सभी जवाब साफ करें)
- **सब ट्री को खिसकाएँ** ( अकेले में टिप्पणी - विरले, लेकिन कभी - कभी ज़रूरत होती है)

## पाँच सवाल

प्रत्येक निकास अपने स्वयं के लेख में विस्तार से भरा है. यहाँ आपके चुनाव करने में मदद करने के लिए एक सारांश है:

---


### 1. Adjeth सूची (प्रेशण संदर्भ)

**[पूरे लेख को पढ़ें](/blog/efcore-hierarchical-data-adjacency)**

सबसे आसान और सबसे सरल तरीका है। प्रत्येक पंक्ति अपने माता पिता नोड के लिए एक संदर्भ भंडारित करता है। यह क्या सबसे अधिक विकासकर्ता पहली बात के लिए तक पहुँचने के लिए है क्योंकि यह प्राकृतिक रूप से हम स्वाभाविक रूप से कैसे विचारों के बारे में सोचते हैं।

**यह कैसे काम करता है:** हर टिप्पणी में नलेबल है `ParentCommentId` स्तम्भ. मूल टिप्पणियाँ रिक्त हैं, उनके माता पिता को उत्तर दें.

**के लिए उत्तम:** जब आप स्वाभाविक रूप से कार्य करने के लिए EFrorolhhhh (5- 6 स्तर से कम) करना चाहते हैं, तो उप- ट्री चाल, जो कि स्वाभाविक रूप से कार्य करने के लिए चाहते हैं.

**ट्रायल्स:** माता - पिताओं या बच्चों को जन्म देने के लिए एक बार फिर CTECT या अलग - अलग जगहों की ज़रूरत होती है ।

---


### 2 सायकल तालिका

**[पूरे लेख को पढ़ें](/blog/efcore-hierarchical-data-closure)**

एक अलग मेज में हर पूर्वज-पुष्ट संबंध रखता है. प्रश्न के समय पर संबंधों का पता लगाने के बजाय, हम उन्हें स्पष्ट रूप से उनके गहराई के साथ जमा करते हैं.

**यह कैसे काम करता है:** अलग `CommentClosure` प्रत्येक जोड़े के लिए तालिका भंडार (ट्रे_id, वंश_id, गहराई). टिप्पणी 3 द्वारा टिप्पणी के अंतर्गत 4 प्रविष्टियों में होता: (1,4,1), (४),4, (४)

**के लिए उत्तम:** जब आप गुप्त रूप से क्वैरी करते हैं तो भारी अनुप्रयोग पढ़ें, जब आप कभी भी उप- वृक्ष को खिसकाते हैं.

**ट्रायल्स:** और भी जटिल प्रविष्ट करता है (और जोड़ने की प्रविष्टियों को जोड़ने की ज़रूरत है), भंडार गहराई से बढ़ता है, और उप- वृक्ष को फिर से निर्माण करने की जरूरत होती है.

---


### 3. भौतिकीकृत पथ

**[पूरे लेख को पढ़ें](/blog/efcore-hierarchical-data-path)**

इसे बस सड़क नाम के बजाय पूरा डाक पता जमा करने के बारे में सोचिए ।

**यह कैसे काम करता है:** हर टिप्पणी में एक है `Path` स्तम्भ "1/3/7" का अर्थ है 1, माता-पिता है 3, यह 7 है. arthers को स्ट्रिंग से पार्स किया जा सकता है, बच्चों की तरह sques के साथ मिलता है.

**के लिए उत्तम:** रोटी की पीढ़ी, जब पूर्वज वंशज से ज्यादा पूछ रहे होते हैं, जब आप डिबगिंग के लिए मानव पढ़ने योग्य पथ चाहते हैं.

**ट्रायल्स:** जैसे दाँतों को सही निर्देशिका के बिना धीमी गति से रखा जा सकता है, पथ वाक्यांशों की लंबाई सीमा होती है, बढ़ते हुए सब वंशज पथों से मुक्‍त होने की माँग करता है ।

---


### ४. नेस्तीय नियत

**[पूरे लेख को पढ़ें](/blog/efcore-hierarchical-data-nested)**

प्रत्येक नोड को एक गहराई- पहले आकार से बाएँ तथा दायाँ किनारा संख्या आबंटित करता है. सभी संतति के मूल्य होते हैं *के बीच में* जनक की सीमाएँ.

**यह कैसे काम करता है:** प्रत्येक टिप्पणी है `Left` और `Right` मान. L=4 के साथ एक नोड, R=7 में सभी नोड्स शामिल हैं जहाँ 4 <L और दाएँ < 7. बच्चे सरल सीमाओं के साथ मिलते हैं.

**के लिए उत्तम:** पढ़ें, श्रेणी के पेड़ों की तरह लिखें. "पूरी उप- दरख्तों को प्रदर्शित करने के लिए अच्छी तरह से खींच लें" अनुक्रमों के रूप में.

**ट्रायल्स:** प्रविष्ट करता है कि कई पंक्तियों को अद्यतन करने की आवश्यकता है (सभी मूल्यों को कमरा बनाने के लिए बन्द करें), उप- वृक्ष जटिल हैं. बार- बार लिखने के लिए उचित नहीं है.

---


### 5. केआईओस्लेवstar name

**[पूरे लेख को पढ़ें](/blog/efcore-hierarchical-data-ltree)**

क्रिप्टो डाटा के लिए एसक्यूएल का स्थानीय एक्सटेंशन. भौतिक पथों की तरह परंतु डाटाबेस- लेवलिंग तथा शक्तिशाली पैटर्न से मेल खाता है.

**यह कैसे काम करता है:** उपयोग `ltree` "1.3. 7" की तरह पथ के साथ डेटा प्रकार. GiBe इंडेक्स सक्षम करता है एक कुशल पूर्वज/ frecents जैसे ऑपरेटरों के प्रयोग से `@>` और `<@`.

**के लिए उत्तम:** जब आपको मेल से मेल खाने की आवश्यकता हो, जब आप भौतिक रूप से खराब पथ चाहते हैं.

**ट्रायल्स:** एसक्यूएल- सिर्फ, डाटाबेस विस्तार निर्भरता को जोड़ता है. टीप: [Negsqufs एलईईएस अनुवाद समर्थित करता है](https://www.npgsql.org/efcore/mapping/translations.html#ltree-functions) के बारे में ' दरख्त' का नाम `LTree` रिकर्सिव सीईएसएएस अभी भी रॉ एसक्यूएल की आवश्यकता है.

---


## तुलना सारांश

MURINTICKINEQQSUYEAS प्रश्न Aje Aje Mart Connector Connector Connector Connector command भंडार को Exe समर्थन प्रदान करता है
|----------|--------|---------------|-----------------|--------------|---------|-----------------|
| **एजाता सूची** IMTECO( n) के साथ CTTEO( न) CTTEOTCONOYOYEOWYECOWYYEONTYEYE( n) बहुत ही बढ़ियाQARTHARTHATH( n) के साथ
| **सुनिश्चित करें कि तालिका** IMSTIO( ) OO( 1) O( 1) O( x d) O( n x d) A( n x d) अच्छा
| **भौतिकीकृत पथ** LibOVO( 1) ओ( 1)* LibONO( 1) OV( s( ) प्रति नोड “%s”
| **संजाल सेट** IMSINO(n) O(n) O(n) On( n) joughffous
| **एल- ट्री** IMTANO( 1) OOL OO( ) प्रति नोड शुभ (क्रिया) `LTree` क़िस्म (C)

*n = कुल नोड्स, d = गहराई, एस = उप- ट्री आकार*
*सही निर्देशिका के साथ

## निर्णय फ़्लोचार्ट

```mermaid
flowchart TD
    Start([Start]) --> Q1{Shallow tree?<br/>< 5 levels}
    Q1 -->|Yes| Q2{Need EF Core<br/>navigation properties?}
    Q2 -->|Yes| AL[Adjacency List]
    Q2 -->|No| Q3{Performance<br/>critical?}
    Q3 -->|No| AL
    Q3 -->|Yes| MP[Materialised Path]

    Q1 -->|No| Q4{Read-heavy?}
    Q4 -->|Yes| Q5{Writes rare?}
    Q5 -->|Yes| NS[Nested Sets]
    Q5 -->|No| CT[Closure Table]

    Q4 -->|No| Q6{PostgreSQL only?}
    Q6 -->|Yes| LT[ltree]
    Q6 -->|No| Q7{Need breadcrumbs?}
    Q7 -->|Yes| MP
    Q7 -->|No| CT

    style Start stroke:#10b981,stroke-width:2px
    style AL stroke:#6366f1,stroke-width:2px
    style MP stroke:#8b5cf6,stroke-width:2px
    style NS stroke:#ec4899,stroke-width:2px
    style CT stroke:#f59e0b,stroke-width:2px
    style LT stroke:#14b8a6,stroke-width:2px
```

## वास्तविक विश्वव्यापी चुनाव: यह ब्लॉग

इस ब्लॉग का इस्तेमाल **सुनिश्चित करें कि तालिका** ध्यान से सुनिए:

1. टिप्पणियाँ अकसर लिखित से कहीं ज़्यादा पढ़ी जाती हैं
2. हमें घोंसले की टिप्पणी बहुत अच्छी तरह से प्रदर्शित करनी होगी
3. गहराई पर निर्भर रहना प्रदर्शन के लिए महत्वपूर्ण है (5 स्तर गहरा हो गया है)
4. टिप्पणियाँ विरले ही होती हैं (स्वीकारों को कभी - कभी ऐसा करने की ज़रूरत होती है)

देखें [भाग 1, 2](/blog/efcore-hierarchical-data-closure) पूरा कार्यान्वयन विवरण के लिए.

## श्रेणी नेविगेशन

- **पार्ट 1: ओवरव्यू** ( इस लेख)
- [पार्ट 1. 1: एजाजेसी सूची](/blog/efcore-hierarchical-data-adjacency) - सादा जनक संदर्भ
- [भाग 1, 2](/blog/efcore-hierarchical-data-closure) - सुरक्षित सम्बन्धों को अलग किया गया है
- [पार्ट 1. 3: भौतिकीकृत पथ](/blog/efcore-hierarchical-data-path) - पथ वाक्यांश
- [भाग 1. 1 1.4: नेक्स्ट सेट](/blog/efcore-hierarchical-data-nested) - बायाँ/ दायाँ सीमाएँ
- [पार्ट 1. 5: l ट्री](/blog/efcore-hierarchical-data-ltree) - एसक्यूएल स्थानीय विस्तार
- पार्ट 2: एसक्यूएल तथा डीपेकर ( जल्द ही आ रहा है)