புரோஹோஸ்டர் > Блог > நிர்வாகம் > C#.NET இல் LINQ வினவல்களை மேம்படுத்துவதற்கான முறைகள்

C#.NET இல் LINQ வினவல்களை மேம்படுத்துவதற்கான முறைகள்

அறிமுகம்

В இந்த கட்டுரையில் சில தேர்வுமுறை முறைகள் கருதப்பட்டன LINQ வினவல்கள்.
குறியீடு தேர்வுமுறை தொடர்பான இன்னும் சில அணுகுமுறைகளையும் இங்கே வழங்குகிறோம் LINQ வினவல்கள்.

அது அறியப்படுகிறது இணைப்பு(மொழி-ஒருங்கிணைந்த வினவல்) என்பது தரவு மூலத்தை வினவுவதற்கான எளிய மற்றும் வசதியான மொழியாகும்.

А LINQ முதல் SQL வரை DBMS இல் தரவை அணுகுவதற்கான தொழில்நுட்பமாகும். இது தரவுகளுடன் பணிபுரிவதற்கான ஒரு சக்திவாய்ந்த கருவியாகும், அங்கு வினவல்கள் ஒரு அறிவிப்பு மொழி மூலம் கட்டமைக்கப்படுகின்றன, பின்னர் அது மாற்றப்படும் SQL வினவல்கள் இயங்குதளம் மற்றும் செயல்பாட்டிற்காக தரவுத்தள சேவையகத்திற்கு அனுப்பப்பட்டது. எங்கள் விஷயத்தில், DBMS என்பதன் அர்த்தம் MS SQL சேவையகம்.

எனினும், LINQ வினவல்கள் சிறந்த முறையில் எழுதப்பட்டவைகளாக மாற்றப்படவில்லை SQL வினவல்கள், ஒரு அனுபவம் வாய்ந்த டிபிஏ தேர்வுமுறையின் அனைத்து நுணுக்கங்களுடனும் எழுத முடியும் SQL வினவல்கள்:

  1. உகந்த இணைப்புகள் (சேர்க) மற்றும் முடிவுகளை வடிகட்டுதல் (எங்கே)
  2. இணைப்புகள் மற்றும் குழு நிலைமைகளைப் பயன்படுத்துவதில் பல நுணுக்கங்கள்
  3. நிலைமைகளை மாற்றுவதில் பல வேறுபாடுகள் IN மீது ஆய்வுகள்и உள் இல்லை, <> அன்று ஆய்வுகள்
  4. தற்காலிக அட்டவணைகள், CTE, அட்டவணை மாறிகள் மூலம் முடிவுகளின் இடைநிலை கேச்சிங்
  5. வாக்கியத்தின் பயன்பாடு (சூதம்) அறிவுறுத்தல்கள் மற்றும் அட்டவணை குறிப்புகளுடன் கொண்டு (...)
  6. தேர்வுகளின் போது தேவையற்ற தரவு அளவீடுகளை அகற்றுவதற்கான வழிமுறைகளில் ஒன்றாக அட்டவணைப்படுத்தப்பட்ட காட்சிகளைப் பயன்படுத்துதல்

இதன் விளைவாக முக்கிய செயல்திறன் தடைகள் SQL வினவல்கள் தொகுக்கும் போது LINQ வினவல்கள் அவை:

  1. ஒரு கோரிக்கையில் முழு தரவு தேர்வு பொறிமுறையையும் ஒருங்கிணைத்தல்
  2. ஒரே மாதிரியான குறியீட்டு தொகுதிகளை நகலெடுக்கிறது, இது இறுதியில் பல தேவையற்ற தரவுகளைப் படிக்க வழிவகுக்கிறது
  3. பல-கூறு நிபந்தனைகளின் குழுக்கள் (தர்க்கரீதியான "மற்றும்" மற்றும் "அல்லது") - மற்றும் и OR, சிக்கலான நிலைகளில் இணைப்பதன் மூலம், தேவையான புலங்களுக்கு பொருத்தமான கிளஸ்டர் அல்லாத குறியீடுகளைக் கொண்ட ஆப்டிமைசர், இறுதியில் கிளஸ்டர்டு இன்டெக்ஸுக்கு எதிராக ஸ்கேன் செய்யத் தொடங்குகிறது (குறியீட்டு ஸ்கேன்) நிபந்தனைகளின் குழுக்களால்
  4. துணை வினவல்களின் ஆழமான கூடு பாகுபடுத்தலை மிகவும் சிக்கலாக்குகிறது SQL அறிக்கைகள் மற்றும் டெவலப்பர்கள் தரப்பில் வினவல் திட்டத்தின் பகுப்பாய்வு மற்றும் டிபிஏ

மேம்படுத்தல் முறைகள்

இப்போது தேர்வுமுறை முறைகளுக்கு நேரடியாக செல்லலாம்.

1) கூடுதல் அட்டவணைப்படுத்தல்

முதன்மைத் தேர்வு அட்டவணையில் வடிப்பான்களைக் கருத்தில் கொள்வது சிறந்தது, ஏனெனில் பெரும்பாலும் முழு வினவலும் ஒன்று அல்லது இரண்டு முக்கிய அட்டவணைகள் (பயன்பாடுகள்-மக்கள்-செயல்பாடுகள்) மற்றும் நிலையான நிபந்தனைகளுடன் (மூடப்பட்டது, ரத்துசெய்யப்பட்டது, இயக்கப்பட்டது, நிலை). அடையாளம் காணப்பட்ட மாதிரிகளுக்கு பொருத்தமான குறியீடுகளை உருவாக்குவது முக்கியம்.

இந்த புலங்களைத் தேர்ந்தெடுக்கும்போது இந்தத் தீர்வு அர்த்தமுள்ளதாக இருக்கும்.

எடுத்துக்காட்டாக, எங்களிடம் 500000 பயன்பாடுகள் உள்ளன. இருப்பினும், 2000 செயலில் உள்ள பயன்பாடுகள் மட்டுமே உள்ளன. சரியாக தேர்ந்தெடுக்கப்பட்ட குறியீடு நம்மை காப்பாற்றும் குறியீட்டு ஸ்கேன் ஒரு பெரிய டேபிளில் மற்றும் க்ளஸ்டர்டு அல்லாத குறியீட்டின் மூலம் தரவை விரைவாக தேர்ந்தெடுக்க உங்களை அனுமதிக்கும்.

மேலும், வினவல் திட்டங்களை பாகுபடுத்துதல் அல்லது கணினி பார்வை புள்ளிவிவரங்களை சேகரிப்பது போன்றவற்றின் மூலம் குறியீடுகளின் பற்றாக்குறையை அடையாளம் காண முடியும். MS SQL சேவையகம்:

  1. sys.dm_db_missing_index_groups
  2. sys.dm_db_missing_index_group_stats
  3. sys.dm_db_missing_index_details

எல்லாப் பார்வைத் தரவிலும் இடஞ்சார்ந்த குறியீடுகளைத் தவிர்த்து விடுபட்ட குறியீடுகள் பற்றிய தகவல்கள் உள்ளன.

இருப்பினும், குறியீடுகள் மற்றும் கேச்சிங் பெரும்பாலும் மோசமாக எழுதப்பட்டதன் விளைவுகளை எதிர்த்துப் போராடும் முறைகள் LINQ வினவல்கள் и SQL வினவல்கள்.

வாழ்க்கையின் கடுமையான நடைமுறை காட்டுவது போல, ஒரு வணிகமானது குறிப்பிட்ட காலக்கெடுவுக்குள் வணிக அம்சங்களை செயல்படுத்துவது பெரும்பாலும் முக்கியம். எனவே, கனமான கோரிக்கைகள் பெரும்பாலும் கேச்சிங் மூலம் பின்னணிக்கு மாற்றப்படும்.

இது ஓரளவு நியாயமானது, ஏனெனில் பயனருக்கு எப்போதும் சமீபத்திய தரவு தேவைப்படாது மற்றும் பயனர் இடைமுகத்தின் ஏற்றுக்கொள்ளக்கூடிய அளவிலான பதிலளிக்கும் தன்மை உள்ளது.

இந்த அணுகுமுறை வணிகத் தேவைகளைத் தீர்க்க உங்களை அனுமதிக்கிறது, ஆனால் இறுதியில் சிக்கல்களுக்கான தீர்வுகளை தாமதப்படுத்துவதன் மூலம் தகவல் அமைப்பின் செயல்திறனைக் குறைக்கிறது.

தேவையான குறியீடுகளைத் தேடும் செயல்பாட்டில், பரிந்துரைகளைச் சேர்க்க வேண்டும் என்பதையும் நினைவில் கொள்வது மதிப்பு MSSQL பின்வரும் நிபந்தனைகள் உட்பட, தேர்வுமுறை தவறாக இருக்கலாம்:

  1. இதேபோன்ற புலங்களின் தொகுப்புடன் ஏற்கனவே குறியீடுகள் இருந்தால்
  2. அட்டவணைப்படுத்தல் கட்டுப்பாடுகள் காரணமாக அட்டவணையில் உள்ள புலங்களை அட்டவணைப்படுத்த முடியாவிட்டால் (மேலும் விரிவாக விவரிக்கப்பட்டுள்ளது இங்கே).

2) ஒரு புதிய பண்புக்கூறில் பண்புகளை இணைத்தல்

சில நேரங்களில் ஒரு அட்டவணையில் உள்ள சில புலங்கள், நிபந்தனைகளின் குழுவிற்கு அடிப்படையாக செயல்படுகின்றன, ஒரு புதிய புலத்தை அறிமுகப்படுத்துவதன் மூலம் மாற்றலாம்.

பொதுவாக பிட் அல்லது முழு எண்ணாக இருக்கும் நிலைப் புலங்களுக்கு இது குறிப்பாகப் பொருந்தும்.

உதாரணம்:

மூடப்பட்டது = 0 மற்றும் ரத்து செய்யப்பட்டது = 0 மற்றும் இயக்கப்பட்டது = 0 மூலம் மாற்றப்படுகிறது நிலை = 1.

இந்த நிலைகள் அட்டவணையில் உள்ளதா என்பதை உறுதிப்படுத்த, முழு எண் நிலை பண்புக்கூறு அறிமுகப்படுத்தப்பட்டது. அடுத்து, இந்த புதிய பண்பு குறியிடப்பட்டது.

செயல்திறன் சிக்கலுக்கு இது ஒரு அடிப்படை தீர்வாகும், ஏனென்றால் தேவையற்ற கணக்கீடுகள் இல்லாமல் தரவை அணுகுகிறோம்.

3) பார்வையின் பொருளாக்கம்

துரதிருஷ்டவசமாக, இல் LINQ வினவல்கள் தற்காலிக அட்டவணைகள், CTEகள் மற்றும் அட்டவணை மாறிகள் நேரடியாகப் பயன்படுத்த முடியாது.

இருப்பினும், இந்த வழக்கை மேம்படுத்த மற்றொரு வழி உள்ளது - அட்டவணைப்படுத்தப்பட்ட காட்சிகள்.

நிபந்தனை குழு (மேலே உள்ள எடுத்துக்காட்டில் இருந்து) மூடப்பட்டது = 0 மற்றும் ரத்து செய்யப்பட்டது = 0 மற்றும் இயக்கப்பட்டது = 0 (அல்லது இதே போன்ற பிற நிபந்தனைகளின் தொகுப்பு) ஒரு பெரிய தொகுப்பிலிருந்து சிறிய அளவிலான தரவைத் தேக்கிவைத்து, குறியீட்டு பார்வையில் அவற்றைப் பயன்படுத்துவதற்கு ஒரு சிறந்த தேர்வாகிறது.

ஆனால் பார்வையை செயல்படுத்தும் போது பல கட்டுப்பாடுகள் உள்ளன:

  1. துணை வினவல்களின் பயன்பாடு, உட்பிரிவுகள் ஆய்வுகள் பயன்படுத்தி மாற்ற வேண்டும் சேர்க
  2. நீங்கள் வாக்கியங்களைப் பயன்படுத்த முடியாது யூனியன், UNION ALL, EXCEPTION, இன்டர்செக்ட்
  3. நீங்கள் அட்டவணை குறிப்புகள் மற்றும் உட்பிரிவுகளைப் பயன்படுத்த முடியாது சூதம்
  4. சுழற்சிகளுடன் வேலை செய்ய வாய்ப்பு இல்லை
  5. வெவ்வேறு அட்டவணைகளிலிருந்து ஒரு பார்வையில் தரவைக் காட்டுவது சாத்தியமில்லை

குறியீட்டு பார்வையைப் பயன்படுத்துவதன் உண்மையான பலனை உண்மையில் அட்டவணைப்படுத்துவதன் மூலம் மட்டுமே அடைய முடியும் என்பதை நினைவில் கொள்வது அவசியம்.

ஆனால் பார்வையை அழைக்கும் போது, ​​இந்த குறியீடுகள் பயன்படுத்தப்படாமல் இருக்கலாம், மேலும் அவற்றை வெளிப்படையாகப் பயன்படுத்த, நீங்கள் குறிப்பிட வேண்டும் உடன்(எக்ஸ்பேண்ட்).

இல் இருந்து LINQ வினவல்கள் அட்டவணை குறிப்புகளை வரையறுக்க இயலாது, எனவே நீங்கள் மற்றொரு பிரதிநிதித்துவத்தை உருவாக்க வேண்டும் - பின்வரும் படிவத்தின் "ரேப்பர்":

CREATE VIEW ИМЯ_представления AS SELECT * FROM MAT_VIEW WITH (NOEXPAND);

4) அட்டவணை செயல்பாடுகளைப் பயன்படுத்துதல்

அடிக்கடி உள்ளே LINQ வினவல்கள் ஒரு சிக்கலான கட்டமைப்பைக் கொண்ட காட்சிகளைப் பயன்படுத்தும் துணை வினவல்களின் பெரிய தொகுதிகள் அல்லது தொகுதிகள் மிகவும் சிக்கலான மற்றும் துணைச் செயலாக்க அமைப்புடன் இறுதி வினவலை உருவாக்குகின்றன.

அட்டவணை செயல்பாடுகளைப் பயன்படுத்துவதன் முக்கிய நன்மைகள் LINQ வினவல்கள்:

  1. பார்வைகளைப் போலவே, ஒரு பொருளாகப் பயன்படுத்தப்படும் மற்றும் குறிப்பிடப்படும் திறன், ஆனால் நீங்கள் உள்ளீட்டு அளவுருக்களின் தொகுப்பை அனுப்பலாம்:
    செயல்பாட்டிலிருந்து (@பரம்1, @பரம்2 ...)
    இதன் விளைவாக, நெகிழ்வான தரவு மாதிரியை அடைய முடியும்
  2. அட்டவணை செயல்பாட்டைப் பயன்படுத்தும் விஷயத்தில், மேலே விவரிக்கப்பட்ட அட்டவணைப்படுத்தப்பட்ட காட்சிகளைப் போன்ற வலுவான கட்டுப்பாடுகள் எதுவும் இல்லை:
    1. அட்டவணை குறிப்புகள்:
      மூலம் இணைப்பு எந்த குறியீடுகள் பயன்படுத்தப்பட வேண்டும் என்பதை நீங்கள் குறிப்பிட முடியாது மற்றும் வினவும்போது தரவு தனிமைப்படுத்தல் அளவை தீர்மானிக்க முடியாது.
      ஆனால் செயல்பாடு இந்த திறன்களைக் கொண்டுள்ளது.
      செயல்பாட்டின் மூலம், நீங்கள் ஒரு நிலையான செயலாக்க வினவல் திட்டத்தை அடைய முடியும், அங்கு குறியீடுகள் மற்றும் தரவு தனிமைப்படுத்தல் நிலைகளுடன் பணிபுரிவதற்கான விதிகள் வரையறுக்கப்படுகின்றன.
    2. செயல்பாட்டைப் பயன்படுத்துவது குறியீட்டு பார்வைகளுடன் ஒப்பிடுகையில், பெற அனுமதிக்கிறது:
      • சிக்கலான தரவு மாதிரி தர்க்கம் (சுழல்களைப் பயன்படுத்தினாலும்)
      • பல்வேறு அட்டவணைகளிலிருந்து தரவைப் பெறுதல்
      • பயன்படுத்த யூனியன் и ஆய்வுகள்

  3. சலுகை சூதம் நாம் ஒத்திசைவுக் கட்டுப்பாட்டை வழங்க வேண்டியிருக்கும் போது மிகவும் பயனுள்ளதாக இருக்கும் விருப்பம்(MAXDOP N), வினவல் செயல்படுத்தும் திட்டத்தின் வரிசை. உதாரணத்திற்கு:
    • வினவல் திட்டத்தின் கட்டாய மறு உருவாக்கத்தை நீங்கள் குறிப்பிடலாம் விருப்பம் (மீண்டும் தொகுத்தல்)
    • வினவலில் குறிப்பிடப்பட்டுள்ள சேரும் வரிசையைப் பயன்படுத்த வினவல் திட்டத்தை கட்டாயப்படுத்த வேண்டுமா என்பதை நீங்கள் குறிப்பிடலாம் விருப்பம் (கட்டாய உத்தரவு)

    பற்றிய கூடுதல் விவரங்கள் சூதம் விவரித்தார் இங்கே.

  4. குறுகிய மற்றும் மிகவும் தேவையான தரவு ஸ்லைஸைப் பயன்படுத்துதல்:
    பெரிய தரவுத் தொகுப்புகளை தற்காலிக சேமிப்பில் சேமிக்க வேண்டிய அவசியமில்லை (குறியீட்டு பார்வைகளைப் போலவே), அதிலிருந்து நீங்கள் இன்னும் அளவுருவின் மூலம் தரவை வடிகட்ட வேண்டும்.
    எடுத்துக்காட்டாக, வடிகட்டியின் அட்டவணை உள்ளது எங்கே மூன்று புலங்கள் பயன்படுத்தப்படுகின்றன (a, b, c).

    வழக்கமாக, அனைத்து கோரிக்கைகளுக்கும் நிலையான நிபந்தனை உள்ளது a = 0 மற்றும் b = 0.

    இருப்பினும் களத்திற்கான கோரிக்கை c மேலும் மாறி.

    நிபந்தனையை விடுங்கள் a = 0 மற்றும் b = 0 தேவையான விளைவான தொகுப்பை ஆயிரக்கணக்கான பதிவுகளுக்கு மட்டுப்படுத்த இது உண்மையில் உதவுகிறது, ஆனால் நிபந்தனை உள்ளது с தேர்வை நூறு பதிவுகளாகக் குறைக்கிறது.

    இங்கே அட்டவணை செயல்பாடு ஒரு சிறந்த தேர்வாக இருக்கலாம்.

    மேலும், ஒரு அட்டவணை செயல்பாடு மிகவும் கணிக்கக்கூடியது மற்றும் செயல்படுத்தும் நேரத்தில் சீரானது.

உதாரணங்கள்

கேள்விகள் தரவுத்தளத்தை உதாரணமாகப் பயன்படுத்தி ஒரு எடுத்துக்காட்டு செயல்படுத்தலைப் பார்ப்போம்.

ஒரு வேண்டுகோள் உள்ளது தேர்வு, இது பல அட்டவணைகளை ஒருங்கிணைத்து ஒரு பார்வையைப் பயன்படுத்துகிறது (Operative Questions), இதில் இணைப்பு மின்னஞ்சல் மூலம் சரிபார்க்கப்படுகிறது (வழியாக ஆய்வுகள்) "செயல்பாட்டு கேள்விகளுக்கு":

கோரிக்கை எண். 1

(@p__linq__0 nvarchar(4000))SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Join2].[Object_Id] AS [Object_Id],
[Join2].[ObjectType_Id] AS [ObjectType_Id],
[Join2].[Name] AS [Name],
[Join2].[ExternalId] AS [ExternalId]
FROM [dbo].[Questions] AS [Extent1]
INNER JOIN (SELECT [Extent2].[Object_Id] AS [Object_Id],
[Extent2].[Question_Id] AS [Question_Id], [Extent3].[ExternalId] AS [ExternalId],
[Extent3].[ObjectType_Id] AS [ObjectType_Id], [Extent4].[Name] AS [Name]
FROM [dbo].[ObjectQuestions] AS [Extent2]
INNER JOIN [dbo].[Objects] AS [Extent3] ON [Extent2].[Object_Id] = [Extent3].[Id]
LEFT OUTER JOIN [dbo].[ObjectTypes] AS [Extent4] 
ON [Extent3].[ObjectType_Id] = [Extent4].[Id] ) AS [Join2] 
ON [Extent1].[Id] = [Join2].[Question_Id]
WHERE ([Extent1].[AnswerId] IS NULL) AND (0 = [Extent1].[Exp]) AND ( EXISTS (SELECT
1 AS [C1]
FROM [dbo].[OperativeQuestions] AS [Extent5]
WHERE (([Extent5].[Email] = @p__linq__0) OR (([Extent5].[Email] IS NULL) 
AND (@p__linq__0 IS NULL))) AND ([Extent5].[Id] = [Extent1].[Id])
));

பார்வை மிகவும் சிக்கலான அமைப்பைக் கொண்டுள்ளது: இது துணை வினவல் இணைப்புகளைக் கொண்டுள்ளது மற்றும் வரிசைப்படுத்தலைப் பயன்படுத்துகிறது வேறுபட்ட, இது பொதுவாக மிகவும் வளம் மிகுந்த செயல்பாடாகும்.

ஆப்பரேட்டிவ் கேள்விகளில் இருந்து ஒரு மாதிரி சுமார் பத்தாயிரம் பதிவுகள்.

இந்த வினவலின் முக்கிய பிரச்சனை என்னவென்றால், வெளிப்புற வினவலில் இருந்து வரும் பதிவுகளுக்கு, [OperativeQuestions] பார்வையில் ஒரு உள் துணை வினவல் செயல்படுத்தப்படுகிறது, இது [Email] = @p__linq__0 க்கு வெளியீடு தேர்வை (வழியாக) கட்டுப்படுத்த அனுமதிக்கும். ஆய்வுகள்) நூற்றுக்கணக்கான பதிவுகள் வரை.

துணை வினவல் பதிவுகளை ஒரு முறை [மின்னஞ்சல்] = @p__linq__0 மூலம் கணக்கிட வேண்டும் என்று தோன்றலாம், பின்னர் இந்த இரண்டு நூறு பதிவுகள் ஐடி மூலம் கேள்விகளுடன் இணைக்கப்பட வேண்டும், மேலும் வினவல் வேகமாக இருக்கும்.

உண்மையில், அனைத்து அட்டவணைகளுக்கும் ஒரு தொடர் இணைப்பு உள்ளது: செயல்பாட்டுக் கேள்விகளிலிருந்து ஐடியுடன் ஐடி கேள்விகளின் கடிதப் பரிமாற்றத்தைச் சரிபார்த்தல் மற்றும் மின்னஞ்சல் மூலம் வடிகட்டுதல்.

உண்மையில், கோரிக்கையானது அனைத்து பல்லாயிரக்கணக்கான செயல்பாட்டுக் கேள்விகள் பதிவுகளிலும் வேலை செய்கிறது, ஆனால் மின்னஞ்சல் வழியாக ஆர்வமுள்ள தரவு மட்டுமே தேவை.

செயல்பாட்டுக் கேள்விகள் உரையைக் காண்க:

கோரிக்கை எண். 2

 
CREATE VIEW [dbo].[OperativeQuestions]
AS
SELECT DISTINCT Q.Id, USR.email AS Email
FROM            [dbo].Questions AS Q INNER JOIN
                         [dbo].ProcessUserAccesses AS BPU ON BPU.ProcessId = CQ.Process_Id 
OUTER APPLY
                     (SELECT   1 AS HasNoObjects
                      WHERE   NOT EXISTS
                                    (SELECT   1
                                     FROM     [dbo].ObjectUserAccesses AS BOU
                                     WHERE   BOU.ProcessUserAccessId = BPU.[Id] AND BOU.[To] IS NULL)
) AS BO INNER JOIN
                         [dbo].Users AS USR ON USR.Id = BPU.UserId
WHERE        CQ.[Exp] = 0 AND CQ.AnswerId IS NULL AND BPU.[To] IS NULL 
AND (BO.HasNoObjects = 1 OR
              EXISTS (SELECT   1
                           FROM   [dbo].ObjectUserAccesses AS BOU INNER JOIN
                                      [dbo].ObjectQuestions AS QBO 
                                                  ON QBO.[Object_Id] =BOU.ObjectId
                               WHERE  BOU.ProcessUserAccessId = BPU.Id 
                               AND BOU.[To] IS NULL AND QBO.Question_Id = CQ.Id));

DbContext இல் ஆரம்ப காட்சி மேப்பிங் (EF கோர் 2)

public class QuestionsDbContext : DbContext
{
    //...
    public DbQuery<OperativeQuestion> OperativeQuestions { get; set; }
    //...
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Query<OperativeQuestion>().ToView("OperativeQuestions");
    }
}

ஆரம்ப LINQ வினவல்

var businessObjectsData = await context
    .OperativeQuestions
    .Where(x => x.Email == Email)
    .Include(x => x.Question)
    .Select(x => x.Question)
    .SelectMany(x => x.ObjectQuestions,
                (x, bo) => new
                {
                    Id = x.Id,
                    ObjectId = bo.Object.Id,
                    ObjectTypeId = bo.Object.ObjectType.Id,
                    ObjectTypeName = bo.Object.ObjectType.Name,
                    ObjectExternalId = bo.Object.ExternalId
                })
    .ToListAsync();

இந்த குறிப்பிட்ட விஷயத்தில், உள்கட்டமைப்பு மாற்றங்கள் இல்லாமல், ஆயத்த முடிவுகளுடன் ("செயலில் உள்ள வினவல்கள்") ஒரு தனி அட்டவணையை அறிமுகப்படுத்தாமல், இந்த சிக்கலுக்குத் தீர்வை நாங்கள் பரிசீலித்து வருகிறோம். .

இது ஒரு நல்ல தீர்வு என்றாலும், இந்த சிக்கலை மேம்படுத்த மற்றொரு விருப்பம் உள்ளது.

[மின்னஞ்சல்] = @p__linq__0 மூலம் உள்ளீடுகளை OperativeQuestions பார்வையில் இருந்து தேக்ககப்படுத்துவதே முக்கிய நோக்கம்.

டேபிள் செயல்பாட்டை [dbo] [OperativeQuestionsUserMail] தரவுத்தளத்தில் அறிமுகப்படுத்தவும்.

மின்னஞ்சலை உள்ளீட்டு அளவுருவாக அனுப்புவதன் மூலம், மதிப்புகளின் அட்டவணையை நாங்கள் திரும்பப் பெறுகிறோம்:

கோரிக்கை எண். 3


CREATE FUNCTION [dbo].[OperativeQuestionsUserMail]
(
    @Email  nvarchar(4000)
)
RETURNS
@tbl TABLE
(
    [Id]           uniqueidentifier,
    [Email]      nvarchar(4000)
)
AS
BEGIN
        INSERT INTO @tbl ([Id], [Email])
        SELECT Id, @Email
        FROM [OperativeQuestions]  AS [x] WHERE [x].[Email] = @Email;
     
    RETURN;
END

இது முன் வரையறுக்கப்பட்ட தரவு கட்டமைப்புடன் மதிப்புகளின் அட்டவணையை வழங்குகிறது.

OperativeQuestionsUserMail க்கான வினவல்கள் உகந்ததாகவும், உகந்த வினவல் திட்டங்களைக் கொண்டிருப்பதற்கும், கண்டிப்பான கட்டமைப்பு தேவை, மற்றும் இல்லை ரிட்டர்ன்ஸ் டேபிள்...

இந்த வழக்கில், தேவையான வினவல் 1 வினவல் 4 ஆக மாற்றப்படுகிறது:

கோரிக்கை எண். 4

(@p__linq__0 nvarchar(4000))SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Join2].[Object_Id] AS [Object_Id],
[Join2].[ObjectType_Id] AS [ObjectType_Id],
[Join2].[Name] AS [Name],
[Join2].[ExternalId] AS [ExternalId]
FROM (
    SELECT Id, Email FROM [dbo].[OperativeQuestionsUserMail] (@p__linq__0)
) AS [Extent0]
INNER JOIN [dbo].[Questions] AS [Extent1] ON([Extent0].Id=[Extent1].Id)
INNER JOIN (SELECT [Extent2].[Object_Id] AS [Object_Id], [Extent2].[Question_Id] AS [Question_Id], [Extent3].[ExternalId] AS [ExternalId], [Extent3].[ObjectType_Id] AS [ObjectType_Id], [Extent4].[Name] AS [Name]
FROM [dbo].[ObjectQuestions] AS [Extent2]
INNER JOIN [dbo].[Objects] AS [Extent3] ON [Extent2].[Object_Id] = [Extent3].[Id]
LEFT OUTER JOIN [dbo].[ObjectTypes] AS [Extent4] 
ON [Extent3].[ObjectType_Id] = [Extent4].[Id] ) AS [Join2] 
ON [Extent1].[Id] = [Join2].[Question_Id]
WHERE ([Extent1].[AnswerId] IS NULL) AND (0 = [Extent1].[Exp]);

DbContext இல் மேப்பிங் காட்சிகள் மற்றும் செயல்பாடுகள் (EF கோர் 2)

public class QuestionsDbContext : DbContext
{
    //...
    public DbQuery<OperativeQuestion> OperativeQuestions { get; set; }
    //...
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Query<OperativeQuestion>().ToView("OperativeQuestions");
    }
}
 
public static class FromSqlQueries
{
    public static IQueryable<OperativeQuestion> GetByUserEmail(this DbQuery<OperativeQuestion> source, string Email)
        => source.FromSql($"SELECT Id, Email FROM [dbo].[OperativeQuestionsUserMail] ({Email})");
}

இறுதி LINQ வினவல்

var businessObjectsData = await context
    .OperativeQuestions
    .GetByUserEmail(Email)
    .Include(x => x.Question)
    .Select(x => x.Question)
    .SelectMany(x => x.ObjectQuestions,
                (x, bo) => new
                {
                    Id = x.Id,
                    ObjectId = bo.Object.Id,
                    ObjectTypeId = bo.Object.ObjectType.Id,
                    ObjectTypeName = bo.Object.ObjectType.Name,
                    ObjectExternalId = bo.Object.ExternalId
                })
    .ToListAsync();

செயல்படுத்தும் நேரத்தின் வரிசையானது 200-800 ms, 2-20 ms, முதலியன குறைந்துள்ளது, அதாவது பல மடங்கு வேகமாக.

நாம் அதை சராசரியாக எடுத்துக் கொண்டால், 350 எம்எஸ்க்கு பதிலாக 8 எம்எஸ் கிடைத்தது.

வெளிப்படையான நன்மைகளிலிருந்து நாங்கள் பெறுகிறோம்:

  1. வாசிப்பு சுமையில் பொதுவான குறைப்பு,
  2. தடுப்பதற்கான சாத்தியக்கூறுகளில் குறிப்பிடத்தக்க குறைப்பு
  3. சராசரி தடுப்பு நேரத்தை ஏற்றுக்கொள்ளக்கூடிய மதிப்புகளுக்கு குறைக்கிறது

முடிவுக்கு

தரவுத்தள அழைப்புகளை மேம்படுத்துதல் மற்றும் நன்றாகச் சரிசெய்தல் MSSQL மூலம் இணைப்பு என்பது தீர்க்கப்படக் கூடிய பிரச்சனை.

இந்த வேலையில் கவனம் மற்றும் நிலைத்தன்மை மிகவும் முக்கியமானது.

செயல்முறையின் தொடக்கத்தில்:

  1. கோரிக்கை செயல்படும் தரவை சரிபார்க்க வேண்டியது அவசியம் (மதிப்புகள், தேர்ந்தெடுக்கப்பட்ட தரவு வகைகள்)
  2. இந்தத் தரவின் சரியான அட்டவணைப்படுத்தலை மேற்கொள்ளுங்கள்
  3. அட்டவணைகளுக்கு இடையில் சேரும் நிபந்தனைகளின் சரியான தன்மையை சரிபார்க்கவும்

அடுத்த தேர்வுமுறை மறு செய்கை வெளிப்படுத்துகிறது:

  1. கோரிக்கையின் அடிப்படை மற்றும் முக்கிய கோரிக்கை வடிகட்டியை வரையறுக்கிறது
  2. ஒரே மாதிரியான வினவல் தொகுதிகளை மீண்டும் கூறுதல் மற்றும் நிபந்தனைகளின் குறுக்குவெட்டை பகுப்பாய்வு செய்தல்
  3. SSMS அல்லது பிற GUI இல் SQL சர்வர் தன்னை மேம்படுத்துகிறது SQL வினவல் (ஒரு இடைநிலை தரவு சேமிப்பகத்தை ஒதுக்குதல், இந்த சேமிப்பகத்தைப் பயன்படுத்தி வினவலை உருவாக்குதல் (பல இருக்கலாம்))
  4. கடைசி கட்டத்தில், விளைவாக ஒரு அடிப்படையாக எடுத்து SQL வினவல், கட்டமைப்பு மீண்டும் கட்டப்பட்டு வருகிறது LINQ வினவல்

இதன் விளைவாக LINQ வினவல் அடையாளம் காணப்பட்ட உகந்த அமைப்பில் ஒரே மாதிரியாக இருக்க வேண்டும் SQL வினவல் புள்ளி 3 இலிருந்து.

ஒப்புதல்கள்

சக ஊழியர்களுக்கு மிக்க நன்றி jobgemws и alex_ozr நிறுவனத்தில் இருந்து ஃபோர்டிஸ் இந்த பொருள் தயாரிப்பதில் உதவிக்காக.

ஆதாரம்: www.habr.com

கருத்தைச் சேர்