MS SQL ಸರ್ವರ್‌ಗಾಗಿ C#.NET ನಲ್ಲಿ LINQ ಪ್ರಶ್ನೆಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವ ಕೆಲವು ಅಂಶಗಳು

LINQ ಪ್ರಬಲವಾದ ಹೊಸ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಭಾಷೆಯಾಗಿ .NET ಅನ್ನು ನಮೂದಿಸಿದೆ. ಅದರ ಭಾಗವಾಗಿ SQL ಗೆ LINQ ನಿಮಗೆ 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 ಫೈಲ್‌ನಲ್ಲಿ, configSections ಅಂಶವನ್ನು ಮುಚ್ಚಿದ ನಂತರ, ನೀವು ಈ ಕೆಳಗಿನ ಬ್ಲಾಕ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ:

<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 ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಇದು ಸಾಮಾನ್ಯ ಕ್ಷೇತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:

ಬೇಸ್ ಕ್ಲಾಸ್ ಬೇಸ್ ಎಂಟಿಟಿಯ ಅನುಷ್ಠಾನ

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; }
    }
}

ಈಗ ಪ್ರತ್ಯೇಕ ಫೈಲ್‌ನಲ್ಲಿ ಬಳಕೆದಾರ ಸಂದರ್ಭವನ್ನು ರಚಿಸೋಣ:

ಯೂಸರ್‌ಕಾಂಟೆಕ್ಸ್ ವರ್ಗದ ಅನುಷ್ಠಾನ

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 ಪ್ರಶ್ನೆಯಲ್ಲಿ ಮತ್ತು ಸ್ಥಿತಿಯನ್ನು 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-запрос работает в разы быстрее, чем неоптимизированный.

Для варианта с И в условиях 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 to Objects вместо запроса вида:

LINQ-запрос (1-й вариант)

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-запрос (2-й вариант)

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" } };

, а тип Para определяется следующим образом:

Определение типа Para

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

Таким образом мы рассмотрели некоторые аспекты в оптимизации LINQ-запросов к MS SQL Server.

К сожалению даже опытные и ведущие .NET-разработчики забывают о том, что необходимо понимать что делают за кадром те инструкции, которые они используют. Иначе они становятся конфигураторами и могут заложить бомбу замедленного действия в будущем как при масштабировании программного решения, так и при незначительных изменениях внешних условий среды.

Также небольшой обзор проводился и ಇಲ್ಲಿ.

Исходники для теста-сам проект, создание таблиц в базе данных TEST, а также наполнение данными этих таблиц находится ಇಲ್ಲಿ.
ಈ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ, ಯೋಜನೆಗಳ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ, OR ಷರತ್ತುಗಳೊಂದಿಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಯೋಜನೆಗಳಿವೆ.

ಮೂಲ: www.habr.com

MS SQL ಸರ್ವರ್‌ಗಾಗಿ C#.NET ನಲ್ಲಿ LINQ ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ಕೆಲವು ಅಂಶಗಳು

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ