Aeth LINQ i mewn i .NET fel iaith drin data newydd bwerus. Mae LINQ i SQL fel rhan ohono yn caniatΓ‘u ichi gyfathrebu Γ’'r DBMS yn eithaf cyfleus gan ddefnyddio, er enghraifft, y Fframwaith Endid. Fodd bynnag, gan ei ddefnyddio'n eithaf aml, mae datblygwyr yn anghofio edrych ar ba fath o ymholiad SQL y bydd y darparwr y gellir ei ymholi yn ei gynhyrchu, yn eich achos chi, y Fframwaith Endid.
Edrychwn ar ddau brif bwynt gydag enghraifft.
I wneud hyn, yn SQL Server byddwn yn creu Prawf cronfa ddata, ac ynddo byddwn yn creu dau dabl gan ddefnyddio'r ymholiad canlynol:
Creu tablau
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
Nawr, gadewch i ni lenwi'r tabl Cyf trwy redeg y sgript ganlynol:
Llenwi'r bwrdd Cyf
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
Gadewch i ni boblogi'r tabl Cwsmer yn yr un modd gan ddefnyddio'r sgript ganlynol:
Poblogi'r tabl Cwsmer
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
Felly, cawsom ddau dabl, ac mae gan un ohonynt fwy nag 1 miliwn o resi o ddata, ac mae gan y llall fwy na 10 miliwn o resi o ddata.
Nawr yn Visual Studio, mae angen i chi greu prosiect prawf Visual C # Console App (. NET Framework):
Nesaf, mae angen ichi ychwanegu llyfrgell i'r Fframwaith Endid ryngweithio Γ’'r gronfa ddata.
I'w ychwanegu, de-gliciwch ar y prosiect a dewis Rheoli Pecynnau NuGet o'r ddewislen cyd-destun:
Yna, yn y ffenestr rheoli pecyn NuGet sy'n ymddangos, yn y blwch chwilio, rhowch y gair "Entity Framework" a dewiswch y pecyn Fframwaith Endid a'i osod:
Nesaf, yn y ffeil App.config, ar Γ΄l cau'r elfen configSections, ychwanegwch y bloc canlynol:
<connectionStrings>
<add name="DBConnection" connectionString="data source=ΠΠΠ―_ΠΠΠΠΠΠΠΠ―Π Π_MSSQL;Initial Catalog=TEST;Integrated Security=True;" providerName="System.Data.SqlClient" />
</connectionStrings>
Yn connectionString mae angen i chi nodi'r llinyn cysylltiad.
Nawr, gadewch i ni greu 3 rhyngwyneb mewn ffeiliau ar wahΓ’n:
- Gweithredu rhyngwyneb IBaseEntityID
namespace TestLINQ { public interface IBaseEntityID { int ID { get; set; } } } - Gweithredu rhyngwyneb IBaseEntityName
namespace TestLINQ { public interface IBaseEntityName { string Name { get; set; } } } - Gweithredu rhyngwyneb IBaseNameInsertUTCDate
namespace TestLINQ { public interface IBaseNameInsertUTCDate { DateTime InsertUTCDate { get; set; } } }
Ac mewn ffeil ar wahΓ’n, byddwn yn creu dosbarth sylfaenol BaseEntity ar gyfer ein dau endid, a fydd yn cynnwys meysydd cyffredin:
Gweithredu'r BaseEntity dosbarth sylfaen
namespace TestLINQ
{
public class BaseEntity : IBaseEntityID, IBaseEntityName, IBaseNameInsertUTCDate
{
public int ID { get; set; }
public string Name { get; set; }
public DateTime InsertUTCDate { get; set; }
}
}
Nesaf, mewn ffeiliau ar wahΓ’n, byddwn yn creu ein dau endid:
- gweithredu dosbarth cyf
using System.ComponentModel.DataAnnotations.Schema; namespace TestLINQ { [Table("Ref")] public class Ref : BaseEntity { public int ID2 { get; set; } } } - Gweithredu'r dosbarth Cwsmer
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; } } }
Nawr, gadewch i ni greu cyd-destun UserContext mewn ffeil ar wahΓ’n:
Gweithredu'r dosbarth 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; }
}
}
Cawsom ateb parod ar gyfer cynnal profion optimeiddio gyda LINQ i SQL trwy EF ar gyfer MS SQL Server:
Nawr yn y ffeil Program.cs, rhowch y cod canlynol:
Ffeil 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();
}
}
}
}
Nesaf, gadewch i ni redeg ein prosiect.
Ar ddiwedd y gwaith, bydd y canlynol yn cael eu harddangos ar y consol:
Wedi cynhyrchu ymholiad 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])
Hynny yw, yn gyffredinol, cynhyrchodd ymholiad LINQ ymholiad SQL i'r MS SQL Server DBMS yn eithaf da.
Nawr, gadewch i ni newid y cyflwr AND i OR yn yr ymholiad LINQ:
ymholiad 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 };
Gadewch i ni redeg ein cais eto.
Bydd y gweithrediad yn chwalu gyda gwall sy'n gysylltiedig ag amser gweithredu'r gorchymyn sy'n fwy na 30 eiliad:
Os edrychwch ar ba ymholiad a gynhyrchwyd gan LINQ:
, yna gallwch chi sicrhau bod y dewis yn digwydd trwy'r cynnyrch Cartesaidd o ddwy set (tablau):
Wedi cynhyrchu ymholiad 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]
Gadewch i ni ailysgrifennu'r ymholiad LINQ fel hyn:
Ymholiad LINQ wedi'i optimeiddio
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 });
Yna cawn yr ymholiad SQL canlynol:
Ymholiad 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]
Ysywaeth, mewn ymholiadau LINQ dim ond un amod ymuno a all fod, felly mae'n bosibl gwneud ymholiad cyfatebol trwy ddau ymholiad am bob amod, ac yna eu hundeb trwy Undeb i gael gwared ar ddyblygiadau ymhlith rhesi.
Bydd, yn gyffredinol ni fydd yr ymholiadau'n cyfateb, o ystyried y gellir dychwelyd rhesi dyblyg cyflawn. Fodd bynnag, mewn bywyd go iawn, nid oes angen llinellau dyblyg llawn a cheisir cael gwared arnynt.
Nawr, gadewch i ni gymharu cynlluniau gweithredu'r ddau ymholiad hyn:
- ar gyfer CROSS JOIN, yr amser gweithredu ar gyfartaledd yw 195 eiliad:
- ar gyfer UNED FEWNOL-UNDEB mae'r amser gweithredu ar gyfartaledd yn llai na 24 eiliad:
Fel y gwelir o'r canlyniadau, ar gyfer dau dabl gyda miliynau o gofnodion, mae'r ymholiad LINQ wedi'i optimeiddio lawer gwaith yn gyflymach na'r un heb ei optimeiddio.
Ar gyfer yr amrywiad gydag AND yn amodau ymholiad LINQ o'r ffurflen:
ymholiad 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 };
bron bob amser bydd ymholiad SQL cywir yn cael ei gynhyrchu, a fydd yn rhedeg ar gyfartaledd am tua 1 eiliad:
Hefyd ar gyfer triniaethau LINQ i Objects yn lle cwestiynu'r farn:
Ymholiad LINQ (opsiwn 1af)
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 };
Gallwch ddefnyddio ymholiad fel:
Ymholiad LINQ (opsiwn 2af)
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 };
lle:
Diffinio dwy arae
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" } };
, a diffinnir y math Para fel a ganlyn:
Math o ddiffiniad para
class Para
{
public int Key1, Key2;
public string Data;
}
Felly, rydym wedi ystyried rhai agweddau wrth optimeiddio ymholiadau LINQ i MS SQL Server.
Yn anffodus, mae hyd yn oed datblygwyr profiadol ac blaenllaw .NET yn anghofio bod angen deall beth mae'r cyfarwyddiadau y maent yn eu defnyddio yn ei wneud y tu Γ΄l i'r llenni. Fel arall, maent yn dod yn gyflunwyr a gallant osod bom amser yn y dyfodol, wrth raddio datrysiad meddalwedd, a chyda mΓ’n newidiadau mewn amodau amgylcheddol allanol.
Cafwyd adolygiad bach hefyd .
Ffynonellau ar gyfer y prawf - mae'r prosiect ei hun, creu tablau yn y gronfa ddata TEST, yn ogystal Γ’ llenwi'r tablau hyn Γ’ data wedi'i leoli .
Hefyd yn y storfa hon yn y ffolder Cynlluniau mae cynlluniau ar gyfer gweithredu ymholiadau gydag amodau NEU.
Ffynhonnell: hab.com