🥇 MS SQL ਸਰਵਰ ਲਈ C#.NET ਵਿੱਚ LINQ ਸਵਾਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੇ ਕੁਝ ਪਹਿਲੂ

LINQ ਨੇ .NET ਨੂੰ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਨਵੀਂ ਡਾਟਾ ਹੇਰਾਫੇਰੀ ਭਾਸ਼ਾ ਵਜੋਂ ਦਾਖਲ ਕੀਤਾ ਹੈ। ਇਸਦੇ ਹਿੱਸੇ ਵਜੋਂ LINQ ਤੋਂ SQL ਤੁਹਾਨੂੰ DBMS ਨਾਲ ਕਾਫ਼ੀ ਸੁਵਿਧਾਜਨਕ ਢੰਗ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਐਂਟਿਟੀ ਫਰੇਮਵਰਕ। ਹਾਲਾਂਕਿ, ਅਕਸਰ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਡਿਵੈਲਪਰ ਇਹ ਦੇਖਣਾ ਭੁੱਲ ਜਾਂਦੇ ਹਨ ਕਿ ਸਵਾਲ ਕਰਨ ਯੋਗ ਪ੍ਰਦਾਤਾ, ਤੁਹਾਡੇ ਕੇਸ ਵਿੱਚ ਐਂਟਿਟੀ ਫਰੇਮਵਰਕ, ਕਿਸ ਕਿਸਮ ਦੀ SQL ਪੁੱਛਗਿੱਛ ਤਿਆਰ ਕਰੇਗਾ।

ਆਉ ਇੱਕ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦੋ ਮੁੱਖ ਨੁਕਤਿਆਂ ਨੂੰ ਵੇਖੀਏ।
ਅਜਿਹਾ ਕਰਨ ਲਈ, SQL ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਟੈਸਟ ਡੇਟਾਬੇਸ ਬਣਾਓ, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੀ ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਵਿੱਚ ਦੋ ਟੇਬਲ ਬਣਾਓ:

ਟੇਬਲ ਬਣਾਉਣਾ

USE [TEST]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[Ref](
	[ID] [int] NOT NULL,
	[ID2] [int] NOT NULL,
	[Name] [nvarchar](255) NOT NULL,
	[InsertUTCDate] [datetime] NOT NULL,
 CONSTRAINT [PK_Ref] PRIMARY KEY CLUSTERED 
(
	[ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

ALTER TABLE [dbo].[Ref] ADD  CONSTRAINT [DF_Ref_InsertUTCDate]  DEFAULT (getutcdate()) FOR [InsertUTCDate]
GO

USE [TEST]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[Customer](
	[ID] [int] NOT NULL,
	[Name] [nvarchar](255) NOT NULL,
	[Ref_ID] [int] NOT NULL,
	[InsertUTCDate] [datetime] NOT NULL,
	[Ref_ID2] [int] NOT NULL,
 CONSTRAINT [PK_Customer] PRIMARY KEY CLUSTERED 
(
	[ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

ALTER TABLE [dbo].[Customer] ADD  CONSTRAINT [DF_Customer_Ref_ID]  DEFAULT ((0)) FOR [Ref_ID]
GO

ALTER TABLE [dbo].[Customer] ADD  CONSTRAINT [DF_Customer_InsertUTCDate]  DEFAULT (getutcdate()) FOR [InsertUTCDate]
GO

ਹੁਣ ਹੇਠਾਂ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾ ਕੇ ਰੈਫ ਟੇਬਲ ਨੂੰ ਤਿਆਰ ਕਰੀਏ:

ਰੈਫ ਟੇਬਲ ਨੂੰ ਭਰਨਾ

USE [TEST]
GO

DECLARE @ind INT=1;

WHILE(@ind<1200000)
BEGIN
	INSERT INTO [dbo].[Ref]
           ([ID]
           ,[ID2]
           ,[Name])
    SELECT
           @ind
           ,@ind
           ,CAST(@ind AS NVARCHAR(255));

	SET @ind=@ind+1;
END 
GO

ਚਲੋ ਇਸੇ ਤਰ੍ਹਾਂ ਹੇਠਾਂ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਾਹਕ ਸਾਰਣੀ ਨੂੰ ਭਰੀਏ:

ਗਾਹਕ ਸਾਰਣੀ ਨੂੰ ਤਿਆਰ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

USE [TEST]
GO

DECLARE @ind INT=1;
DECLARE @ind_ref INT=1;

WHILE(@ind<=12000000)
BEGIN
	IF(@ind%3=0) SET @ind_ref=1;
	ELSE IF (@ind%5=0) SET @ind_ref=2;
	ELSE IF (@ind%7=0) SET @ind_ref=3;
	ELSE IF (@ind%11=0) SET @ind_ref=4;
	ELSE IF (@ind%13=0) SET @ind_ref=5;
	ELSE IF (@ind%17=0) SET @ind_ref=6;
	ELSE IF (@ind%19=0) SET @ind_ref=7;
	ELSE IF (@ind%23=0) SET @ind_ref=8;
	ELSE IF (@ind%29=0) SET @ind_ref=9;
	ELSE IF (@ind%31=0) SET @ind_ref=10;
	ELSE IF (@ind%37=0) SET @ind_ref=11;
	ELSE SET @ind_ref=@ind%1190000;
	
	INSERT INTO [dbo].[Customer]
	           ([ID]
	           ,[Name]
	           ,[Ref_ID]
	           ,[Ref_ID2])
	     SELECT
	           @ind,
	           CAST(@ind AS NVARCHAR(255)),
	           @ind_ref,
	           @ind_ref;


	SET @ind=@ind+1;
END
GO

ਇਸ ਤਰ੍ਹਾਂ, ਸਾਨੂੰ ਦੋ ਟੇਬਲ ਪ੍ਰਾਪਤ ਹੋਏ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਡੇਟਾ ਦੀਆਂ 1 ਮਿਲੀਅਨ ਤੋਂ ਵੱਧ ਕਤਾਰਾਂ ਹਨ, ਅਤੇ ਦੂਜੀ ਵਿੱਚ ਡੇਟਾ ਦੀਆਂ 10 ਮਿਲੀਅਨ ਤੋਂ ਵੱਧ ਕਤਾਰਾਂ ਹਨ।

ਹੁਣ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇੱਕ ਟੈਸਟ ਵਿਜ਼ੂਅਲ C# ਕੰਸੋਲ ਐਪ (.NET ਫਰੇਮਵਰਕ) ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ:

ਅੱਗੇ, ਤੁਹਾਨੂੰ ਡੇਟਾਬੇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਇਕਾਈ ਫਰੇਮਵਰਕ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ।
ਇਸ ਨੂੰ ਜੋੜਨ ਲਈ, ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਸੱਜਾ-ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਸੰਦਰਭ ਮੀਨੂ ਤੋਂ NuGet ਪੈਕੇਜ ਪ੍ਰਬੰਧਿਤ ਕਰੋ ਦੀ ਚੋਣ ਕਰੋ:

ਫਿਰ, ਦਿਸਣ ਵਾਲੀ NuGet ਪੈਕੇਜ ਪ੍ਰਬੰਧਨ ਵਿੰਡੋ ਵਿੱਚ, ਖੋਜ ਵਿੰਡੋ ਵਿੱਚ "ਐਂਟਿਟੀ ਫਰੇਮਵਰਕ" ਸ਼ਬਦ ਦਰਜ ਕਰੋ ਅਤੇ ਇਕਾਈ ਫਰੇਮਵਰਕ ਪੈਕੇਜ ਨੂੰ ਚੁਣੋ ਅਤੇ ਇਸਨੂੰ ਸਥਾਪਿਤ ਕਰੋ:

ਅੱਗੇ, App.config ਫਾਈਲ ਵਿੱਚ, configSection ਤੱਤ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਬਲਾਕ ਨੂੰ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ:

<connectionStrings>
    <add name="DBConnection" connectionString="data source=ИМЯ_ЭКЗЕМПЛЯРА_MSSQL;Initial Catalog=TEST;Integrated Security=True;" providerName="System.Data.SqlClient" />
</connectionStrings>

ਕਨੈਕਸ਼ਨਸਟ੍ਰਿੰਗ ਵਿੱਚ ਤੁਹਾਨੂੰ ਕਨੈਕਸ਼ਨ ਸਤਰ ਦਰਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਹੁਣ ਵੱਖ-ਵੱਖ ਫਾਈਲਾਂ ਵਿੱਚ 3 ਇੰਟਰਫੇਸ ਬਣਾਉ:

IBaseEntityID ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

namespace TestLINQ
{
    public interface IBaseEntityID
    {
        int ID { get; set; }
    }
}

IBaseEntityName ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

namespace TestLINQ
{
    public interface IBaseEntityName
    {
        string Name { get; set; }
    }
}

IBaseNameInsertUTCDate ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

namespace TestLINQ
{
    public interface IBaseNameInsertUTCDate
    {
        DateTime InsertUTCDate { get; set; }
    }
}

ਅਤੇ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਅਸੀਂ ਆਪਣੀਆਂ ਦੋ ਸੰਸਥਾਵਾਂ ਲਈ ਇੱਕ ਬੇਸ ਕਲਾਸ BaseEntity ਬਣਾਵਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਸਾਂਝੇ ਖੇਤਰ ਸ਼ਾਮਲ ਹੋਣਗੇ:

ਬੇਸ ਕਲਾਸ BaseEntity ਨੂੰ ਲਾਗੂ ਕਰਨਾ

namespace TestLINQ
{
    public class BaseEntity : IBaseEntityID, IBaseEntityName, IBaseNameInsertUTCDate
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public DateTime InsertUTCDate { get; set; }
    }
}

ਅੱਗੇ, ਅਸੀਂ ਆਪਣੀਆਂ ਦੋ ਸੰਸਥਾਵਾਂ ਨੂੰ ਵੱਖਰੀਆਂ ਫਾਈਲਾਂ ਵਿੱਚ ਬਣਾਵਾਂਗੇ:

ਰੈਫ ਕਲਾਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

using System.ComponentModel.DataAnnotations.Schema;

namespace TestLINQ
{
    [Table("Ref")]
    public class Ref : BaseEntity
    {
        public int ID2 { get; set; }
    }
}

ਗਾਹਕ ਵਰਗ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

using System.ComponentModel.DataAnnotations.Schema;

namespace TestLINQ
{
    [Table("Customer")]
    public class Customer: BaseEntity
    {
        public int Ref_ID { get; set; }
        public int Ref_ID2 { get; set; }
    }
}

ਹੁਣ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਇੱਕ UserContext ਸੰਦਰਭ ਬਣਾਉ:

UserContex ਕਲਾਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

using System.Data.Entity;

namespace TestLINQ
{
    public class UserContext : DbContext
    {
        public UserContext()
            : base("DbConnection")
        {
            Database.SetInitializer<UserContext>(null);
        }

        public DbSet<Customer> Customer { get; set; }
        public DbSet<Ref> Ref { get; set; }
    }
}

ਸਾਨੂੰ MS SQL ਸਰਵਰ ਲਈ EF ਦੁਆਰਾ LINQ ਤੋਂ SQL ਦੇ ਨਾਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਟੈਸਟ ਕਰਵਾਉਣ ਲਈ ਇੱਕ ਤਿਆਰ-ਬਣਾਇਆ ਹੱਲ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ:

ਹੁਣ Program.cs ਫਾਈਲ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਦਾਖਲ ਕਰੋ:

Program.cs ਫ਼ਾਈਲ

using System;
using System.Collections.Generic;
using System.Linq;

namespace TestLINQ
{
    class Program
    {
        static void Main(string[] args)
        {
            using (UserContext db = new UserContext())
            {
                var dblog = new List<string>();
                db.Database.Log = dblog.Add;

                var query = from e1 in db.Customer
                            from e2 in db.Ref
                            where (e1.Ref_ID == e2.ID)
                                 && (e1.Ref_ID2 == e2.ID2)
                            select new { Data1 = e1.Name, Data2 = e2.Name };

                var result = query.Take(1000).ToList();

                Console.WriteLine(dblog[1]);

                Console.ReadKey();
            }
        }
    }
}

ਅੱਗੇ, ਆਓ ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ ਲਾਂਚ ਕਰੀਏ।

ਕੰਮ ਦੇ ਅੰਤ 'ਤੇ, ਕੰਸੋਲ 'ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ:

ਤਿਆਰ ਕੀਤੀ SQL ਪੁੱਛਗਿੱਛ

SELECT TOP (1000) 
    [Extent1].[Ref_ID] AS [Ref_ID], 
    [Extent1].[Name] AS [Name], 
    [Extent2].[Name] AS [Name1]
    FROM  [dbo].[Customer] AS [Extent1]
    INNER JOIN [dbo].[Ref] AS [Extent2] ON ([Extent1].[Ref_ID] = [Extent2].[ID]) AND ([Extent1].[Ref_ID2] = [Extent2].[ID2])

ਯਾਨੀ, ਆਮ ਤੌਰ 'ਤੇ, LINQ ਕਿਊਰੀ ਨੇ MS SQL ਸਰਵਰ DBMS ਲਈ ਇੱਕ SQL ਪੁੱਛਗਿੱਛ ਕਾਫ਼ੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਕੀਤੀ ਹੈ।

ਆਓ ਹੁਣ LINQ ਪੁੱਛਗਿੱਛ ਵਿੱਚ AND ਕੰਡੀਸ਼ਨ ਨੂੰ OR ਵਿੱਚ ਬਦਲੀਏ:

LINQ ਪੁੱਛਗਿੱਛ

var query = from e1 in db.Customer
                            from e2 in db.Ref
                            where (e1.Ref_ID == e2.ID)
                                || (e1.Ref_ID2 == e2.ID2)
                            select new { Data1 = e1.Name, Data2 = e2.Name };

ਅਤੇ ਆਓ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਲਾਂਚ ਕਰੀਏ।

ਕਮਾਂਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ 30 ਸਕਿੰਟਾਂ ਤੋਂ ਵੱਧ ਹੋਣ ਕਾਰਨ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਗਲਤੀ ਨਾਲ ਕ੍ਰੈਸ਼ ਹੋ ਜਾਵੇਗਾ:

ਜੇਕਰ ਤੁਸੀਂ LINQ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਗਈ ਪੁੱਛਗਿੱਛ ਨੂੰ ਦੇਖਦੇ ਹੋ:

, ਫਿਰ ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਚੋਣ ਦੋ ਸੈੱਟਾਂ (ਟੇਬਲ) ਦੇ ਕਾਰਟੇਸ਼ੀਅਨ ਉਤਪਾਦ ਦੁਆਰਾ ਹੁੰਦੀ ਹੈ:

ਤਿਆਰ ਕੀਤੀ SQL ਪੁੱਛਗਿੱਛ

SELECT TOP (1000) 
    [Extent1].[Ref_ID] AS [Ref_ID], 
    [Extent1].[Name] AS [Name], 
    [Extent2].[Name] AS [Name1]
    FROM  [dbo].[Customer] AS [Extent1]
    CROSS JOIN [dbo].[Ref] AS [Extent2]
    WHERE [Extent1].[Ref_ID] = [Extent2].[ID] OR [Extent1].[Ref_ID2] = [Extent2].[ID2]

ਆਓ LINQ ਪੁੱਛਗਿੱਛ ਨੂੰ ਹੇਠਾਂ ਲਿਖੇ ਅਨੁਸਾਰ ਦੁਬਾਰਾ ਲਿਖੀਏ:

ਅਨੁਕੂਲਿਤ LINQ ਪੁੱਛਗਿੱਛ

var query = (from e1 in db.Customer
                   join e2 in db.Ref
                   on e1.Ref_ID equals e2.ID
                   select new { Data1 = e1.Name, Data2 = e2.Name }).Union(
                        from e1 in db.Customer
                        join e2 in db.Ref
                        on e1.Ref_ID2 equals e2.ID2
                        select new { Data1 = e1.Name, Data2 = e2.Name });

ਫਿਰ ਸਾਨੂੰ ਹੇਠ ਦਿੱਤੀ SQL ਪੁੱਛਗਿੱਛ ਮਿਲਦੀ ਹੈ:

SQL ਪੁੱਛਗਿੱਛ

SELECT 
    [Limit1].[C1] AS [C1], 
    [Limit1].[C2] AS [C2], 
    [Limit1].[C3] AS [C3]
    FROM ( SELECT DISTINCT TOP (1000) 
        [UnionAll1].[C1] AS [C1], 
        [UnionAll1].[Name] AS [C2], 
        [UnionAll1].[Name1] AS [C3]
        FROM  (SELECT 
            1 AS [C1], 
            [Extent1].[Name] AS [Name], 
            [Extent2].[Name] AS [Name1]
            FROM  [dbo].[Customer] AS [Extent1]
            INNER JOIN [dbo].[Ref] AS [Extent2] ON [Extent1].[Ref_ID] = [Extent2].[ID]
        UNION ALL
            SELECT 
            1 AS [C1], 
            [Extent3].[Name] AS [Name], 
            [Extent4].[Name] AS [Name1]
            FROM  [dbo].[Customer] AS [Extent3]
            INNER JOIN [dbo].[Ref] AS [Extent4] ON [Extent3].[Ref_ID2] = [Extent4].[ID2]) AS [UnionAll1]
    )  AS [Limit1]

ਹਾਏ, LINQ ਪੁੱਛਗਿੱਛਾਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਜੋੜਨ ਦੀ ਸ਼ਰਤ ਹੋ ਸਕਦੀ ਹੈ, ਇਸਲਈ ਇੱਥੇ ਹਰੇਕ ਸ਼ਰਤ ਲਈ ਦੋ ਸਵਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਤੇ ਫਿਰ ਕਤਾਰਾਂ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਨੂੰ ਹਟਾਉਣ ਲਈ ਯੂਨੀਅਨ ਦੁਆਰਾ ਉਹਨਾਂ ਨੂੰ ਜੋੜ ਕੇ ਇੱਕ ਬਰਾਬਰ ਪੁੱਛਗਿੱਛ ਕਰਨਾ ਸੰਭਵ ਹੈ।
ਹਾਂ, ਪੁੱਛਗਿੱਛਾਂ ਆਮ ਤੌਰ 'ਤੇ ਗੈਰ-ਬਰਾਬਰ ਹੋਣਗੀਆਂ, ਇਸ ਗੱਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਕਿ ਪੂਰੀ ਡੁਪਲੀਕੇਟ ਕਤਾਰਾਂ ਵਾਪਸ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਹਾਲਾਂਕਿ, ਅਸਲ ਜ਼ਿੰਦਗੀ ਵਿੱਚ, ਪੂਰੀ ਡੁਪਲੀਕੇਟ ਲਾਈਨਾਂ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਲੋਕ ਉਨ੍ਹਾਂ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ.

ਆਉ ਹੁਣ ਇਹਨਾਂ ਦੋ ਸਵਾਲਾਂ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਲਾਨ ਦੀ ਤੁਲਨਾ ਕਰੀਏ:

CROSS JOIN ਲਈ ਔਸਤ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ 195 ਸਕਿੰਟ ਹੈ:
INNER JoIN-UNION ਲਈ ਔਸਤ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ 24 ਸਕਿੰਟਾਂ ਤੋਂ ਘੱਟ ਹੈ:

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਨਤੀਜਿਆਂ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਲੱਖਾਂ ਰਿਕਾਰਡਾਂ ਵਾਲੀਆਂ ਦੋ ਟੇਬਲਾਂ ਲਈ, ਅਨੁਕੂਲਿਤ LINQ ਪੁੱਛਗਿੱਛ ਗੈਰ-ਅਨੁਕੂਲਿਤ ਨਾਲੋਂ ਕਈ ਗੁਣਾ ਤੇਜ਼ ਹੈ।

ਸ਼ਰਤਾਂ ਵਿੱਚ AND ਦੇ ਵਿਕਲਪ ਲਈ, ਫਾਰਮ ਦੀ ਇੱਕ LINQ ਪੁੱਛਗਿੱਛ:

LINQ ਪੁੱਛਗਿੱਛ

var query = from e1 in db.Customer
                            from e2 in db.Ref
                            where (e1.Ref_ID == e2.ID)
                                 && (e1.Ref_ID2 == e2.ID2)
                            select new { Data1 = e1.Name, Data2 = e2.Name };

ਸਹੀ SQL ਪੁੱਛਗਿੱਛ ਲਗਭਗ ਹਮੇਸ਼ਾਂ ਤਿਆਰ ਕੀਤੀ ਜਾਵੇਗੀ, ਜੋ ਔਸਤਨ 1 ਸਕਿੰਟ ਵਿੱਚ ਚੱਲੇਗੀ:

ਇੱਕ ਪੁੱਛਗਿੱਛ ਦੀ ਬਜਾਏ LINQ ਤੋਂ ਆਬਜੈਕਟ ਹੇਰਾਫੇਰੀ ਲਈ ਵੀ:

LINQ ਪੁੱਛਗਿੱਛ (ਪਹਿਲਾ ਵਿਕਲਪ)

var query = from e1 in seq1
                            from e2 in seq2
                            where (e1.Key1==e2.Key1)
                               && (e1.Key2==e2.Key2)
                            select new { Data1 = e1.Data, Data2 = e2.Data };

ਤੁਸੀਂ ਇੱਕ ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ:

LINQ ਪੁੱਛਗਿੱਛ (ਪਹਿਲਾ ਵਿਕਲਪ)

var query = from e1 in seq1
                            join e2 in seq2
                            on new { e1.Key1, e1.Key2 } equals new { e2.Key1, e2.Key2 }
                            select new { Data1 = e1.Data, Data2 = e2.Data };

ਜਿੱਥੇ:

ਦੋ ਐਰੇ ਦੀ ਪਰਿਭਾਸ਼ਾ

Para[] seq1 = new[] { new Para { Key1 = 1, Key2 = 2, Data = "777" }, new Para { Key1 = 2, Key2 = 3, Data = "888" }, new Para { Key1 = 3, Key2 = 4, Data = "999" } };
Para[] seq2 = new[] { new Para { Key1 = 1, Key2 = 2, Data = "777" }, new Para { Key1 = 2, Key2 = 3, Data = "888" }, new Para { Key1 = 3, Key2 = 5, Data = "999" } };

, ਅਤੇ ਪੈਰਾ ਕਿਸਮ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ:

ਪੈਰਾ ਟਾਈਪ ਪਰਿਭਾਸ਼ਾ

class Para
{
        public int Key1, Key2;
        public string Data;
}

ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ MS SQL ਸਰਵਰ ਲਈ LINQ ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਕੁਝ ਪਹਿਲੂਆਂ ਦੀ ਜਾਂਚ ਕੀਤੀ।

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਤਜਰਬੇਕਾਰ ਅਤੇ ਮੋਹਰੀ .NET ਡਿਵੈਲਪਰ ਇਹ ਭੁੱਲ ਜਾਂਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਉਹ ਜੋ ਨਿਰਦੇਸ਼ ਵਰਤਦੇ ਹਨ ਉਹ ਪਰਦੇ ਦੇ ਪਿੱਛੇ ਕੀ ਕਰਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, ਉਹ ਸੰਰਚਨਾਕਾਰ ਬਣ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸਾਫਟਵੇਅਰ ਹੱਲ ਨੂੰ ਸਕੇਲ ਕਰਨ ਵੇਲੇ ਅਤੇ ਬਾਹਰੀ ਵਾਤਾਵਰਣ ਦੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀਆਂ ਦੇ ਨਾਲ ਭਵਿੱਖ ਵਿੱਚ ਇੱਕ ਟਾਈਮ ਬੰਬ ਲਗਾ ਸਕਦੇ ਹਨ।

ਇੱਕ ਸੰਖੇਪ ਸਮੀਖਿਆ ਵੀ ਕੀਤੀ ਗਈ ਇੱਥੇ.

ਟੈਸਟ ਲਈ ਸਰੋਤ - ਪ੍ਰੋਜੈਕਟ ਖੁਦ, ਟੈਸਟ ਡੇਟਾਬੇਸ ਵਿੱਚ ਟੇਬਲਾਂ ਦੀ ਰਚਨਾ, ਅਤੇ ਨਾਲ ਹੀ ਇਹਨਾਂ ਟੇਬਲਾਂ ਨੂੰ ਡੇਟਾ ਨਾਲ ਭਰਨਾ ਸਥਿਤ ਹੈ ਇੱਥੇ.
ਇਸ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ, ਪਲਾਨ ਫੋਲਡਰ ਵਿੱਚ, OR ਸ਼ਰਤਾਂ ਨਾਲ ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਯੋਜਨਾਵਾਂ ਹਨ।

ਸਰੋਤ: www.habr.com

MS SQL ਸਰਵਰ ਲਈ C#.NET ਵਿੱਚ LINQ ਸਵਾਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੇ ਕੁਝ ਪਹਿਲੂ

ਇੱਕ ਟਿੱਪਣੀ ਜੋੜੋ Отменить ответ