c# - LINQ में बाएं बाहरी जॉइन



join (16)

सी # LINQ में बाएं बाहरी शामिल करने के लिए खंडों join-on-equals-into बिना ऑब्जेक्ट्स के बिना ऑब्जेक्ट्स को कैसे करें? क्या क्लॉज के साथ ऐसा करने का कोई तरीका है? सही समस्या: आंतरिक शामिल होने के लिए आसान है और मेरे पास इसका समाधान है

List<JoinPair> innerFinal = (from l in lefts from r in rights where l.Key == r.Key
                             select new JoinPair { LeftId = l.Id, RightId = r.Id})

लेकिन बाईं ओर शामिल होने के लिए मुझे एक समाधान की आवश्यकता है। मेरा ऐसा कुछ है लेकिन यह काम नहीं कर रहा है

List< JoinPair> leftFinal = (from l in lefts from r in rights
                             select new JoinPair { 
                                            LeftId = l.Id, 
                                            RightId = ((l.Key==r.Key) ? r.Id : 0
                                        })

जहां जॉइनपेयर एक वर्ग है:

public class JoinPair { long leftId; long rightId; }

Answers

यह एक एसक्यूएल वाक्यविन्यास है जो आंतरिक और बाएं बाहरी जुड़ने के लिए LINQ वाक्यविन्यास की तुलना करता है। बाईं ओर का बाहरी जोड़:

http://www.ozkary.com/2011/07/linq-to-entity-inner-and-left-joins.html

"निम्नलिखित उदाहरण उत्पाद और श्रेणी के बीच एक समूह में शामिल होता है। यह अनिवार्य रूप से बाएं शामिल है। अभिव्यक्ति में डेटा तालिका खाली होने पर भी डेटा लौटाता है। श्रेणी तालिका के गुणों तक पहुंचने के लिए, अब हमें गणनात्मक परिणाम से चयन करना होगा catlist.DefaultIfEmpty () कथन में सीएल से जोड़कर।


Linq सी # // में बाएं बाहरी जुड़ें प्रदर्शन करें बाएं बाहरी जुड़ें प्रदर्शन करें

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Child
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}
public class JoinTest
{
    public static void LeftOuterJoinExample()
    {
        Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
        Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
        Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
        Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };

        Child barley = new Child { Name = "Barley", Owner = terry };
        Child boots = new Child { Name = "Boots", Owner = terry };
        Child whiskers = new Child { Name = "Whiskers", Owner = charlotte };
        Child bluemoon = new Child { Name = "Blue Moon", Owner = terry };
        Child daisy = new Child { Name = "Daisy", Owner = magnus };

        // Create two lists.
        List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
        List<Child> childs = new List<Child> { barley, boots, whiskers, bluemoon, daisy };

        var query = from person in people
                    join child in childs
                    on person equals child.Owner into gj
                    from subpet in gj.DefaultIfEmpty()
                    select new
                    {
                        person.FirstName,
                        ChildName = subpet!=null? subpet.Name:"No Child"
                    };
                       // PetName = subpet?.Name ?? String.Empty };

        foreach (var v in query)
        {
            Console.WriteLine($"{v.FirstName + ":",-25}{v.ChildName}");
        }
    }

    // This code produces the following output:
    //
    // Magnus:        Daisy
    // Terry:         Barley
    // Terry:         Boots
    // Terry:         Blue Moon
    // Charlotte:     Whiskers
    // Arlene:        No Child

https://dotnetwithhamid.blogspot.in/


Necromancing।
यदि डेटाबेस संचालित LINQ प्रदाता का उपयोग किया जाता है, तो एक महत्वपूर्ण रूप से अधिक पठनीय बाएं बाहरी जुड़ने को इस प्रकार लिखा जा सकता है:

from maintable in Repo.T_Whatever 
from xxx in Repo.T_ANY_TABLE.Where(join condition).DefaultIfEmpty()

यदि आप DefaultIfEmpty() छोड़ देते हैं तो आपके भीतर आंतरिक शामिल होगा।

स्वीकृत उत्तर लें:

  from c in categories
    join p in products on c equals p.Category into ps
    from p in ps.DefaultIfEmpty()

यह वाक्यविन्यास बहुत भ्रमित है, और यह स्पष्ट नहीं है कि जब आप बहु तालिका में शामिल होना चाहते हैं तो यह कैसे काम करता है।

ध्यान दें
यह ध्यान दिया जाना चाहिए कि from alias in Repo.whatever.Where(condition).DefaultIfEmpty() जो भी from alias in Repo.whatever.Where(condition).DefaultIfEmpty() बाहरी-लागू / बाएं-जॉइन-पार्श्व के समान है, जो कि कोई भी (गैर-मंद) डेटाबेस-ऑप्टिमाइज़र अनुवाद करने में पूरी तरह से सक्षम है बाएं में शामिल होने तक, जब तक आप प्रति-पंक्ति-मूल्यों को प्रस्तुत नहीं करते हैं (उर्फ एक वास्तविक बाहरी लागू होता है)। लिंक-2-ऑब्जेक्ट्स में ऐसा न करें (क्योंकि जब आप लिंक-टू-ऑब्जेक्ट्स का उपयोग करते हैं तो कोई डीबी-ऑप्टिमाइज़र नहीं होता है)।

विस्तृत उदाहरण

var query2 = (
    from users in Repo.T_User
    from mappings in Repo.T_User_Group
         .Where(mapping => mapping.USRGRP_USR == users.USR_ID)
         .DefaultIfEmpty() // <== makes join left join
    from groups in Repo.T_Group
         .Where(gruppe => gruppe.GRP_ID == mappings.USRGRP_GRP)
         .DefaultIfEmpty() // <== makes join left join

    // where users.USR_Name.Contains(keyword)
    // || mappings.USRGRP_USR.Equals(666)  
    // || mappings.USRGRP_USR == 666 
    // || groups.Name.Contains(keyword)

    select new
    {
         UserId = users.USR_ID
        ,UserName = users.USR_User
        ,UserGroupId = groups.ID
        ,GroupName = groups.Name
    }

);


var xy = (query2).ToList();

जब LINQ 2 SQL के साथ उपयोग किया जाता है तो यह निम्न बहुत ही सुस्पष्ट SQL क्वेरी में अच्छी तरह से अनुवाद करेगा:

SELECT 
     users.USR_ID AS UserId 
    ,users.USR_User AS UserName 
    ,groups.ID AS UserGroupId 
    ,groups.Name AS GroupName 
FROM T_User AS users

LEFT JOIN T_User_Group AS mappings
   ON mappings.USRGRP_USR = users.USR_ID

LEFT JOIN T_Group AS groups
    ON groups.GRP_ID == mappings.USRGRP_GRP

संपादित करें:

एक और जटिल उदाहरण के लिए " लिंक क्वेरी में SQL सर्वर क्वेरी कनवर्ट करें " भी देखें।

इसके अलावा, यदि आप इसे लिंक-2-ऑब्जेक्ट्स (लिंक-2-एसक्यूएल के बजाए) में कर रहे हैं, तो आपको इसे पुराने तरीके से करना चाहिए (क्योंकि LINQ से SQL को ऑपरेशन में शामिल होने के लिए सही तरीके से अनुवाद किया जाता है, लेकिन इस विधि को ऑब्जेक्ट्स पर एक पूर्ण स्कैन को मजबूर करता है, और इंडेक्स खोजों का लाभ नहीं लेता है, क्यों ...):

    var query2 = (
    from users in Repo.T_Benutzer
    join mappings in Repo.T_Benutzer_Benutzergruppen on mappings.BEBG_BE equals users.BE_ID into tmpMapp
    join groups in Repo.T_Benutzergruppen on groups.ID equals mappings.BEBG_BG into tmpGroups
    from mappings in tmpMapp.DefaultIfEmpty()
    from groups in tmpGroups.DefaultIfEmpty()
    select new
    {
         UserId = users.BE_ID
        ,UserName = users.BE_User
        ,UserGroupId = mappings.BEBG_BG
        ,GroupName = groups.Name
    }

);

यदि आपको 2 से अधिक तालिकाओं में शामिल होने की आवश्यकता है तो यहां एक उदाहरण दिया गया है:

from d in context.dc_tpatient_bookingd
join bookingm in context.dc_tpatient_bookingm 
     on d.bookingid equals bookingm.bookingid into bookingmGroup
from m in bookingmGroup.DefaultIfEmpty()
join patient in dc_tpatient
     on m.prid equals patient.prid into patientGroup
from p in patientGroup.DefaultIfEmpty()

रेफरी: https://.com/a/17142392/2343



विस्तार विधियों द्वारा बाएं बाहरी जुड़ने का कार्यान्वयन जैसा दिख सकता है

public static IEnumerable<Result> LeftJoin<TOuter, TInner, TKey, Result>(
  this IEnumerable<TOuter> outer, IEnumerable<TInner> inner
  , Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
  , Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
  {
    if (outer == null)
      throw new ArgumentException("outer");

    if (inner == null)
      throw new ArgumentException("inner");

    if (outerKeySelector == null)
      throw new ArgumentException("outerKeySelector");

    if (innerKeySelector == null)
      throw new ArgumentException("innerKeySelector");

    if (resultSelector == null)
      throw new ArgumentException("resultSelector");

    return LeftJoinImpl(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer ?? EqualityComparer<TKey>.Default);
  }

  static IEnumerable<Result> LeftJoinImpl<TOuter, TInner, TKey, Result>(
      IEnumerable<TOuter> outer, IEnumerable<TInner> inner
      , Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
      , Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
  {
    var innerLookup = inner.ToLookup(innerKeySelector, comparer);

    foreach (var outerElment in outer)
    {
      var outerKey = outerKeySelector(outerElment);
      var innerElements = innerLookup[outerKey];

      if (innerElements.Any())
        foreach (var innerElement in innerElements)
          yield return resultSelector(outerElment, innerElement);
      else
        yield return resultSelector(outerElment, default(TInner));
     }
   }

परिणाम चयनकर्ता को तब शून्य तत्वों का ख्याल रखना पड़ता है। Fx।

   static void Main(string[] args)
   {
     var inner = new[] { Tuple.Create(1, "1"), Tuple.Create(2, "2"), Tuple.Create(3, "3") };
     var outer = new[] { Tuple.Create(1, "11"), Tuple.Create(2, "22") };

     var res = outer.LeftJoin(inner, item => item.Item1, item => item.Item1, (it1, it2) =>
     new { Key = it1.Item1, V1 = it1.Item2, V2 = it2 != null ? it2.Item2 : default(string) });

     foreach (var item in res)
       Console.WriteLine(string.Format("{0}, {1}, {2}", item.Key, item.V1, item.V2));
   }

लैम्ब्डा अभिव्यक्ति का प्रयोग करना

db.Categories    
  .GroupJoin(
      db.Products,
      Category => Category.CategoryId,
      Product => Product.CategoryId,
      (x, y) => new { Category = x, Products = y })
  .SelectMany(
      xy => xy.Products.DefaultIfEmpty(),
      (x, y) => new { Category = x.Category, Product = y })
  .Select(s => new
  {
      CategoryName = s.Category.Name,     
      ProductName = s.Product.Name   
  })

एक्सटेंशन विधि जो सिंटैक्स में शामिल होने के साथ बाएं जुड़ने जैसी काम करती है

public static class LinQExtensions
{
    public static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(
        this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, 
        Func<TOuter, TKey> outerKeySelector, 
        Func<TInner, TKey> innerKeySelector, 
        Func<TOuter, TInner, TResult> resultSelector)
    {
        return outer.GroupJoin(
            inner, 
            outerKeySelector, 
            innerKeySelector,
            (outerElement, innerElements) => resultSelector(outerElement, innerElements.FirstOrDefault()));
    }
}

बस इसे .NET कोर में लिखा है और ऐसा लगता है कि यह अपेक्षित काम कर रहा है।

छोटा परीक्षण:

        var Ids = new List<int> { 1, 2, 3, 4};
        var items = new List<Tuple<int, string>>
        {
            new Tuple<int, string>(1,"a"),
            new Tuple<int, string>(2,"b"),
            new Tuple<int, string>(4,"d"),
            new Tuple<int, string>(5,"e"),
        };

        var result = Ids.LeftJoin(
            items,
            id => id,
            item => item.Item1,
            (id, item) => item ?? new Tuple<int, string>(id, "not found"));

        result.ToList()
        Count = 4
        [0]: {(1, a)}
        [1]: {(2, b)}
        [2]: {(3, not found)}
        [3]: {(4, d)}

यह सामान्य रूप है (जैसा कि पहले से ही अन्य उत्तरों में प्रदान किया गया है)

var c =
    from a in alpha
    join b in beta on b.field1 equals a.field1 into b_temp
    from b_value in b_temp.DefaultIfEmpty()
    select new { Alpha = a, Beta = b_value };

हालांकि यहां एक स्पष्टीकरण है कि मुझे उम्मीद है कि इसका अर्थ क्या होगा!

join b in beta on b.field1 equals a.field1 into b_temp

अनिवार्य रूप से एक अलग परिणाम सेट b_temp बनाता है जो दाएं हाथ की प्रविष्टियों ('बी' में प्रविष्टियों) के लिए प्रभावी रूप से शून्य 'पंक्तियां' शामिल करता है।

फिर अगली पंक्ति:

from b_value in b_temp.DefaultIfEmpty()

उस परिणाम सेट पर ..इटरेट्स, दाईं ओर 'पंक्ति' के लिए डिफ़ॉल्ट शून्य मान सेट करना, और दाएं हाथ की पंक्ति के परिणाम को 'b_value' के मान में शामिल करना (यानी दाहिने ओर वाला मान हाथ की तरफ, यदि कोई मेल खाता है, या यदि वहां नहीं है तो 'शून्य')।

अब, यदि दाएं हाथ की तरफ एक अलग LINQ क्वेरी का नतीजा है, तो इसमें गुमनाम प्रकार शामिल होंगे, जो केवल 'कुछ' या 'शून्य' हो सकते हैं। यदि यह एक गणना योग्य है (उदाहरण के लिए एक सूची - जहां MyObjectB 2 फ़ील्ड वाले वर्ग है), तो इसके गुणों के लिए डिफ़ॉल्ट 'शून्य' मानों का उपयोग करने के बारे में विशिष्ट होना संभव है:

var c =
    from a in alpha
    join b in beta on b.field1 equals a.field1 into b_temp
    from b_value in b_temp.DefaultIfEmpty( new MyObjectB { Field1 = String.Empty, Field2 = (DateTime?) null })
    select new { Alpha = a, Beta_field1 = b_value.Field1, Beta_field2 = b_value.Field2 };

यह सुनिश्चित करता है कि 'बी' स्वयं शून्य नहीं है (लेकिन इसके गुण आपके द्वारा निर्दिष्ट डिफ़ॉल्ट शून्य मानों का उपयोग करके शून्य हो सकते हैं), और यह आपको b_value के लिए शून्य संदर्भ अपवाद के बिना b_value के गुणों की जांच करने की अनुमति देता है। ध्यान दें कि एक नामुमकिन डेटटाइम के लिए, 'डेटटाइम?) यानी' नाइटटेबल डेटटाइम 'का एक प्रकार' डिफ़ॉल्ट 'त्रुटि' के लिए विनिर्देश में शून्य के 'प्रकार' के रूप में निर्दिष्ट किया जाना चाहिए (यह उन प्रकारों पर भी लागू होगा जो मूल रूप से नहीं हैं 'शून्य, उदाहरण के लिए डबल, फ्लोट)।

आप उपर्युक्त वाक्यविन्यास को आसानी से चेन करके एकाधिक बाएं बाहरी जुड़ सकते हैं।


मैं यह जोड़ना चाहता हूं कि यदि आपको मोरलिंक एक्सटेंशन मिलता है तो अब दोनों समरूप और विषम बाएं जुड़ने के लिए समर्थन है

http://morelinq.github.io/2.8/ref/api/html/Overload_MoreLinq_MoreEnumerable_LeftJoin.htm

उदाहरण:

//Pretend a ClientCompany object and an Employee object both have a ClientCompanyID key on them

return DataContext.ClientCompany
    .LeftJoin(DataContext.Employees,                         //Table being joined
        company => company.ClientCompanyID,                  //First key
        employee => employee.ClientCompanyID,                //Second Key
        company => new {company, employee = (Employee)null}, //Result selector when there isn't a match
        (company, employee) => new { company, employee });   //Result selector when there is a match

संपादित करें:

पूर्वदर्शी में यह काम कर सकता है, लेकिन यह IQueryable को IENumerable में परिवर्तित करता है क्योंकि अधिकlinq क्वेरी को SQL में परिवर्तित नहीं करता है।

आप यहां वर्णित समूह समूह का उपयोग कर सकते हैं: https://.com/a/24273804/4251433

यह सुनिश्चित करेगा कि यदि आप बाद में इसके बारे में और अधिक तर्कसंगत संचालन करने की आवश्यकता है तो यह एक IQueryable के रूप में रहता है।


इस example पर एक नज़र डालें। यह क्वेरी काम करनी चाहिए:

var leftFinal =
        from l in lefts
        join r in rights on l equals r.Left into lrs
        from lr in lrs.DefaultIfEmpty()
        select new { LeftId = l.Id, RightId = ((l.Key==r.Key) ? r.Id : 0 };

बाएं बाहरी जॉइन के लिए सरल समाधान:

var setA = context.SetA;
var setB = context.SetB.Select(st=>st.Id).Distinct().ToList();
var leftOuter  = setA.Where(stA=> !setB.Contains(stA.Id)); 

नोट्स :

  • प्रदर्शन को बेहतर बनाने के लिए सेटबी को एक शब्दकोश में परिवर्तित किया जा सकता है (यदि यह किया जाता है तो आपको इसे बदलना होगा :! SetB.Contains (stA.Id) ) या हैशसेट
  • जब एक से अधिक फ़ील्ड शामिल होते हैं तो यह सेट ऑपरेशंस और एक वर्ग का उपयोग करके प्राप्त किया जा सकता है: IEqualityComparer

इस उदाहरण को देखो

class Person
{
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Phone { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void LeftOuterJoinExample()
{
    Person magnus = new Person {ID = 1, FirstName = "Magnus", LastName = "Hedlund"};
    Person terry = new Person {ID = 2, FirstName = "Terry", LastName = "Adams"};
    Person charlotte = new Person {ID = 3, FirstName = "Charlotte", LastName = "Weiss"};
    Person arlene = new Person {ID = 4, FirstName = "Arlene", LastName = "Huff"};

    Pet barley = new Pet {Name = "Barley", Owner = terry};
    Pet boots = new Pet {Name = "Boots", Owner = terry};
    Pet whiskers = new Pet {Name = "Whiskers", Owner = charlotte};
    Pet bluemoon = new Pet {Name = "Blue Moon", Owner = terry};
    Pet daisy = new Pet {Name = "Daisy", Owner = magnus};

    // Create two lists.
    List<Person> people = new List<Person> {magnus, terry, charlotte, arlene};
    List<Pet> pets = new List<Pet> {barley, boots, whiskers, bluemoon, daisy};

    var query = from person in people
        where person.ID == 4
        join pet in pets on person equals pet.Owner  into personpets
        from petOrNull in personpets.DefaultIfEmpty()
        select new { Person=person, Pet = petOrNull}; 



    foreach (var v in query )
    {
        Console.WriteLine("{0,-15}{1}", v.Person.FirstName + ":", (v.Pet == null ? "Does not Exist" : v.Pet.Name));
    }
}

यहां संदर्भ है

कैसे करें: बाएं बाहरी जुड़ें (सी # प्रोग्रामिंग गाइड)


(from a in db.Assignments
     join b in db.Deliveryboys on a.AssignTo equals b.EmployeeId  

     //from d in eGroup.DefaultIfEmpty()
     join  c in  db.Deliveryboys on a.DeliverTo equals c.EmployeeId into eGroup2
     from e in eGroup2.DefaultIfEmpty()
     where (a.Collected == false)
     select new
     {
         OrderId = a.OrderId,
         DeliveryBoyID = a.AssignTo,
         AssignedBoyName = b.Name,
         Assigndate = a.Assigndate,
         Collected = a.Collected,
         CollectedDate = a.CollectedDate,
         CollectionBagNo = a.CollectionBagNo,
         DeliverTo = e == null ? "Null" : e.Name,
         DeliverDate = a.DeliverDate,
         DeliverBagNo = a.DeliverBagNo,
         Delivered = a.Delivered

     });

class Program
{
    List<Employee> listOfEmp = new List<Employee>();
    List<Department> listOfDepart = new List<Department>();

    public Program()
    {
        listOfDepart = new List<Department>(){
            new Department { Id = 1, DeptName = "DEV" },
            new Department { Id = 2, DeptName = "QA" },
            new Department { Id = 3, DeptName = "BUILD" },
            new Department { Id = 4, DeptName = "SIT" }
        };


        listOfEmp = new List<Employee>(){
            new Employee { Empid = 1, Name = "Manikandan",DepartmentId=1 },
            new Employee { Empid = 2, Name = "Manoj" ,DepartmentId=1},
            new Employee { Empid = 3, Name = "Yokesh" ,DepartmentId=0},
            new Employee { Empid = 3, Name = "Purusotham",DepartmentId=0}
        };

    }
    static void Main(string[] args)
    {
        Program ob = new Program();
        ob.LeftJoin();
        Console.ReadLine();
    }

    private void LeftJoin()
    {
        listOfEmp.GroupJoin(listOfDepart.DefaultIfEmpty(), x => x.DepartmentId, y => y.Id, (x, y) => new { EmpId = x.Empid, EmpName = x.Name, Dpt = y.FirstOrDefault() != null ? y.FirstOrDefault().DeptName : null }).ToList().ForEach
            (z =>
            {
                Console.WriteLine("Empid:{0} EmpName:{1} Dept:{2}", z.EmpId, z.EmpName, z.Dpt);
            });
    }
}

class Employee
{
    public int Empid { get; set; }
    public string Name { get; set; }
    public int DepartmentId { get; set; }
}

class Department
{
    public int Id { get; set; }
    public string DeptName { get; set; }
}

OUTPUT


एक एसक्यूएल जॉइन क्लॉज का इस्तेमाल दो या दो से अधिक तालिकाओं से पंक्तियों को गठबंधन करने के लिए किया जाता है, जो उनके बीच एक सामान्य क्षेत्र के आधार पर होता है।

एसक्यूएल में विभिन्न प्रकार के जॉइन उपलब्ध हैं:

अंदरूनी जॉइन : दोनों टेबलों में एक मैच होने पर पंक्तियां लौटाती हैं।

बाएं जॉइन : बाएं टेबल से सभी पंक्तियां लौटाती हैं, भले ही सही तालिका में कोई मिलान न हो।

दाएं जॉइन : बाएं टेबल में कोई मिलान नहीं होने पर भी, सही तालिका से सभी पंक्तियां लौटाती हैं।

पूर्ण जॉइन : यह बाएं और दाएं बाहरी जुड़ने दोनों के परिणामों को जोड़ती है।

शामिल तालिका में दोनों टेबलों के सभी रिकॉर्ड होंगे और किसी भी तरफ लापता मैचों के लिए एनयूएलएल भरें।

स्वयं जॉइन : तालिका में शामिल होने के लिए प्रयोग किया जाता है जैसे कि तालिका दो टेबल थी, अस्थायी रूप से SQL कथन में कम से कम एक तालिका का नाम बदल रहा था।

कार्टूनियन जॉइन : दो या दो से अधिक जुड़ी तालिकाओं से रिकॉर्ड के सेट के कार्टेशियन उत्पाद को लौटाता है।

हम विवरण में प्रत्येक पहले चार शामिल हो सकते हैं:

हमारे पास निम्नलिखित मानों के साथ दो टेबल हैं।

TableA

id  firstName                  lastName
.......................................
1   arun                        prasanth                 
2   ann                         antony                   
3   sruthy                      abc                      
6   new                         abc                                           

TableB

id2 age Place
................
1   24  kerala
2   24  usa
3   25  ekm
5   24  chennai

.................................................. ..................

आंतरिक रूप से जुड़ा

नोट : यह दो तालिकाओं का चौराहे देता है, यानी टेबल और टेबलबी में वे पंक्तियां आम हैं

वाक्य - विन्यास

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;

इसे हमारी नमूना तालिका में लागू करें:

SELECT TableA.firstName,TableA.lastName,TableB.age,TableB.Place
FROM TableA
INNER JOIN TableB
ON TableA.id = TableB.id2;

परिणाम होगा

firstName       lastName       age  Place
..............................................
arun            prasanth        24  kerala
ann             antony          24  usa
sruthy          abc             25  ekm

बाँया जोड़

नोट : टेबलए में सभी चयनित पंक्तियां, साथ ही तालिकाबी में किसी भी सामान्य चयनित पंक्तियां प्रदान करेंगी।

वाक्य - विन्यास

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;

इसे हमारी नमूना तालिका में लागू करें:

SELECT TableA.firstName,TableA.lastName,TableB.age,TableB.Place
FROM TableA
LEFT JOIN TableB
ON TableA.id = TableB.id2;

परिणाम

firstName                   lastName                    age   Place
...............................................................................
arun                        prasanth                    24    kerala
ann                         antony                      24    usa
sruthy                      abc                         25    ekm
new                         abc                         NULL  NULL

सही जॉइन

नोट : तालिका बी में सभी चयनित पंक्तियां, साथ ही तालिकाए में किसी भी सामान्य चयनित पंक्तियां प्रदान करेंगी।

वाक्य - विन्यास

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_field = table2.common_field;

इसे हमारी नमूना तालिका में लागू करें:

SELECT TableA.firstName,TableA.lastName,TableB.age,TableB.Place
FROM TableA
RIGHT JOIN TableB
ON TableA.id = TableB.id2;

परिणाम

firstName                   lastName                    age     Place
...............................................................................
arun                        prasanth                    24     kerala
ann                         antony                      24     usa
sruthy                      abc                         25     ekm
NULL                        NULL                        24     chennai

पूर्ण जॉइन

नोट : यह यूनियन ऑपरेशन के समान है, यह सभी चयनित मानों को दोनों टेबलों से वापस कर देगा।

वाक्य - विन्यास

SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_field = table2.common_field;

इसे हमारी नमूना तालिका में लागू करें:

SELECT TableA.firstName,TableA.lastName,TableB.age,TableB.Place
FROM TableA
FULL JOIN TableB
ON TableA.id = TableB.id2;

परिणाम

firstName                   lastName                    age    Place
...............................................................................
arun                        prasanth                    24    kerala
ann                         antony                      24    usa
sruthy                      abc                         25    ekm
new                         abc                         NULL  NULL
NULL                        NULL                        24    chennai

रोचक तथ्य

INNER के लिए आदेश में शामिल होने के लिए कोई फर्क नहीं पड़ता

के लिए (बाएं, दाएं या पूर्ण) बाहरी शामिल होता है, ऑर्डर मायने रखता है

इस Link देखने के लिए बेहतर यह आपको आदेश में शामिल होने के बारे में दिलचस्प जानकारी देगा





c# linq join