Ja, die werden eigentlich jede Nacht neu erstellt.

verwendetes Datenbanksystem: MSSQL

Hi Leute,

ich verzweifle mal wieder am SQL-Server.
Ich hab einen Query, der bisher auf dem Produktivsystem immer hochperformant funktioniert hat. Seit einigen Tagen benötigt er jedoch immense Ausführungszeiten von mehreren Minuten.

Ich habe mir den ExecutionPlan angesehen, finde jedoch nicht außergewöhnliches. Führe ich den gleichen Query auf dem Entwicklungssystem aus, erhalte ich auch genau den gleichen Ausführungsplan. Sogar die geschätzten und tatsächlichen Details-Werte sind in etwas gleich.

Ich weiß nun gar nicht wo ich ansetzten kann, da das Entwicklungssystem auch fast die gleichen Daten beinhaltet. Auch die Prozentsätze sind exakt die selben.

Anbeiist der Ausführungsplan.

Vielen Dank für jegliche Hilfe.

Ich analysiere Webseiten und muss viele Daten im Speicher halten, da es teilweise nötig ist, URL-Bezüge herzustellen.

Ich habe den RedGate-Profiler und das Laufzeitverhalten analysiert. Dieser weißt mir jedoch die teuersten Pfade in bereichen auf, die autoag laufen, ohne mit den großen Datenlisten zu arbeiten.

Hallo zusammen,

ich habe eine WPF-Applikation, die ziemlich viele im Arbeitsspeicher hält. Das Problem ist, dass die ganze Applikation immer langsamer wird, je mehr Daten gehalten werden, ohne das diese Daten direkt etwas mit der Laufzeit zu tun haben.

Im Moment ist es so, dass ab ca. 4GB kaum noch zügiges Arbeiten möglich ist.
Weiß jemand woran das liegt ?

Wenn ich die Reihenfolge umkehre passiert gar nix.

Mir ist gerade noch aufgefallen, dass wenn ich den Parameter in der Schreibweise änder. Z.B. @projectId2, es ebenfalls ca. 3 Minuten dauert.

Er benutzt dann auch einen anderen Ausführungplan, der wesentlich schlechter ist. Wie kann ich den SQL-Server jedoch dazu bewegen, den besseren Ausführungsplan zu benutzen?

Mir scheint so, als hätte der SQL-Server noch einen Plan im Cache, der wesentlich besser ist, als die Pläne, die er neu erstellt. Aber wie soll ich ihn dazu bringen, diesen Plan wieder zu verwenden/zu generieren?

verwendetes Datenbanksystem: MSSQL

Ich hab folgende beiden Aufrufe eine Table-Valued User-Defined Functions gegeneinander gebenchmarkt.

Der erste Aufruf brauch ca. 2 Sekunden, während der zweite Aufruf ca. 3 Minuten (!) braucht. Wie kann so etwas sein?

declare @projectId int = 1537;

Select * from MonitoringGsc_KeywordDevelopment_GetDevelopmentData(@projectId, '2016-08-16 00:00:00', '2016-08-31 00:00:00', 0, 20, N'')

Select * from MonitoringGsc_KeywordDevelopment_GetDevelopmentData(1537, '2016-08-16 00:00:00', '2016-08-31 00:00:00', 0, 20, N'')

verwendetes Datenbanksystem: MSSQL

Hallo zusammen.
Ich habe ein Programm, das autag auf einem eigenen Server liegt und Daten sammelt. Hierbei kommen teilweise mehrere Millionen Datensätze zusammen.
Diese Datensätze müssen nun an den Server übertragen werden und dort möglichst performant eingespielt werden.
Ich benutze sonst das EF6. Es hiermit zu machen ist jedoch sehr unperformant. Der Weg den ich bisher gehe ist über eine StoredProcedure mit einem Custom Type die Daten einzuspielen.

Ein weiterer Weg den ich überlegt habe war, alle Datensätze in ein Dump-SQL-File zu speichern und dieses dann auf dem Server über Kommandozeile einzuspielen.

Was habt ihr noch für Vorschläge?

Hmm, ich sehe gerade, dass es nach einem Neustart des SQL-Servers wieder funktionier !?!?!

verwendetes Datenbanksystem: MSSQL

Hallo zusammen,

ich verwende das EF um auf einen SQL-Server zuzugreifen.
Dort habe ich eine Funktion definiert.
Wenn ich die Funktion direkt aufrufen (z.B. über das Management-Studio) so hat sie eine kaum wahrnehmbare Laufzeit.

Wird sie jedoch über das EF im .Net-Code aufgerufen, so führt sie fast immer zum Timeout. Mit dem Profiler habe ich beobachtet, was genau aufgerufen wird

exec sp_executesql N'SELECT 
    1 AS [C1], 
    [Extent1].[KeywordId] AS [KeywordId], 
    [Extent1].[KeywordValue] AS [KeywordValue], 
    [Extent1].[RankingUrlFrom] AS [RankingUrlFrom], 
    [Extent1].[RankingUrlTo] AS [RankingUrlTo], 
    [Extent1].[RankingFrom] AS [RankingFrom], 
    [Extent1].[RankingTo] AS [RankingTo], 
    [Extent1].[Competition] AS [Competition], 
    [Extent1].[AverageMonthlySearches] AS [AverageMonthlySearches], 
    [Extent1].[IndexPoints] AS [IndexPoints]
    FROM [dbo].[Monitoring_KeywordUrlSwitches_GetData](@projectId, @fromDate, @toDate) AS [Extent1]',N'@projectId int,@fromDate datetime2(7),@toDate datetime2(7)',@projectId=1247,@fromDate='2016-06-13 00:00:00',@toDate='2016-06-20 00:00:00'

Kopiere ich diesen Code in Management-Studio so habe ich wieder eine Laufzeit, von unter einer Sekunde.

Was ist hier das Problem?

verwendetes Datenbanksystem: MSSQL

Hallo zusammen.

Wenn ich mit

ALTER TABLE Table
ADD UrlMd5 AS Hashbytes('MD5', Url);
GO

einen Hashwert über ein Spalte erzeuge, wird der dann immer live aktualisiert, oder wird der einmal berechnet und fest in die Tabelle geschrieben ?

Ich habe die Spalte nämlich gerade bei einer Tabelle mit ca. 20 Mio Datensätzen hinzugefügt und es ging rasend schnell ???

bzw. die Andere Frage wäre ob er sich bei der Abfrage live berechnet, oder nur bei einer Änderung aktualisiert.

Danke euch

Ich habs mal runtergebrochen auf ein simples Beispiel:

Meine Linq-Abfrage über EF sieht wie folgt aus:

	var dateToParsed = DateTime.Now.Date.AddDays(-3);
	var dateFromParsed = dateToParsed.AddDays(-30);

	var items = MonitoringGsc_Common_GetKeywordData_ByKeyword(2, dateFromParsed, dateToParsed, null, null, null, null ).OrderBy(x => x.Position);
	
	var test = items.ToList();

Die optimale Version, die generiert werden könnte (und eine Laufzeit von ca. 300ms hat) sieht wie folgt aus:

exec sp_executesql N'SELECT [t0].[KeywordId], [t0].[KeywordValue], [t0].[Position], [t0].[Impressions], [t0].[Clicks], [t0].[ClickThroughRate], [t0].[NumberOfUrls]
FROM [dbo].[MonitoringGsc_Common_GetKeywordData_ByKeyword](@p0, @p1, @p2, NULL, NULL, NULL, NULL) AS [t0]
ORDER BY [t0].[Position]',N'@p0 int,@p1 date,@p2 date',@p0=2,@p1='2016-02-21',@p2='2016-03-22'

letztendlich einfach ein order-by an die Table-Value-Function dran gehangen und fertig ist.

EF generiert jedoch folgendes SQL (Laufzeit ca. 12000ms !!)

exec sp_executesql N'SELECT 
    [Project1].[C1] AS [C1], 
    [Project1].[KeywordId] AS [KeywordId], 
    [Project1].[KeywordValue] AS [KeywordValue], 
    [Project1].[Position] AS [Position], 
    [Project1].[Impressions] AS [Impressions], 
    [Project1].[Clicks] AS [Clicks], 
    [Project1].[ClickThroughRate] AS [ClickThroughRate], 
    [Project1].[NumberOfUrls] AS [NumberOfUrls]
    FROM ( SELECT 
        [Extent1].[KeywordId] AS [KeywordId], 
        [Extent1].[KeywordValue] AS [KeywordValue], 
        [Extent1].[Position] AS [Position], 
        [Extent1].[Impressions] AS [Impressions], 
        [Extent1].[Clicks] AS [Clicks], 
        [Extent1].[ClickThroughRate] AS [ClickThroughRate], 
        [Extent1].[NumberOfUrls] AS [NumberOfUrls], 
        1 AS [C1]
        FROM [dbo].[MonitoringGsc_Common_GetKeywordData_ByKeyword](@ProjectId, @dateFrom, @dateTo, @deviceId, @countryId, @searchTypeId, @numberOfUrls) AS [Extent1]
    )  AS [Project1]
    ORDER BY [Project1].[Position] ASC',N'@ProjectId int,@dateFrom datetime2(7),@dateTo datetime2(7),@deviceId int,@countryId int,@searchTypeId int,@numberOfUrls int',@ProjectId=2,@dateFrom='2016-02-21 00:00:00',@dateTo='2016-03-22 00:00:00',@deviceId=NULL,@countryId=NULL,@searchTypeId=NULL,@numberOfUrls=NULL

Der Execution-Plan ist natürlich auch ein ganz anderer bei den Laufzeitunterschieden.

Gruß

Also in meinem Fall ist es wirklich der Query.

Ich gucken mir mit dem Datenbank-Profiler an, welche Querys an die DB gesendet werden. Die Querys, welche das EF generiert sind auch beim manuellen ausführen sehr unperformant.

Konkret ersetzte das EF mir z.B. "group by" Statements durch verkettete Queries.

verwendetes Datenbanksystem: EF 6.0 SQL Server 2012

Hi zusammen.
Mir ist es jetzt schon des öfteren aufgefallen, dass das EF manchmal Code generiert, der sehr viel unperformanter ist, als der Query, den ich manuell schreiben würde.

Kann man da irgendwas machen?

verwendetes Datenbanksystem: MSSQL

Hallo zusammen,

ich habe mal eine relativ banale Fragen, finde jedoch im Internet keine eindeutige Antwort.

Wenn ich eine Tabelle im SQL-Server um eine Nullable-Datenfeld (z.B. Nullable<int>) erweiter, kostet dieses Feld dann den Speicherplatz des Datentypen oder weniger, wenn kein Wert vorhanden ist?

Es könnte ja sein, dass sich der SQL-Server diese Feld mit einem entsprechendem Bit flaggt. Ich weiß nur nicht, ob er zusätzlich schon Speicher reserviert, für den richtigen Wert.

Weiß jemand darüber bescheid?

Danke!

verwendetes Datenbanksystem: MSSQL

Hallo zusammen, ich habe folgenden Query geschrieben

declare @ProjectId int = 1145;

declare @data TABLE (
   Date   date     NOT NULL,
   KeywordId int NOT NULL,
   KeywordValue nvarchar(max) NOT NULL,
   RankingUrl nvarchar(max) NOT NULL,
   Ranking int      NOT NULL,
   Page int Not Null,
   Competition float NULL,
   AverageMonthlySearches int Not NULL,
   IndexPoints float      NOT NULL
) 

declare @fromDate date = Convert(date, GETDATE() , 101)
	declare @toDate date = Convert(date, GETDATE() - 7 , 101)
	declare @domainId int 
	Select @domainId = MonitoringModule_DomainId from Projects where id = @ProjectId

	insert @data
	SELECT KeywordRankingData.Date, sk.KeywordId, sk.KeywordValue, KeywordRankingsUrls.Url, Ranking, Page, COALESCE(sk.Competition, 0), COALESCE(sk.AverageMonthlySearches, 0), (dbo.CalculateIndexPoints(Ranking, AverageMonthlySearches))
	from Monitoring_Common_GetSelectedKeywords(@ProjectId) as sk
	Join KeywordRankingData on sk.KeywordId = KeywordRankingData.KeywordId
	Join KeywordRankingsUrls on KeywordRankingData.UrlId = KeywordRankingsUrls.Id

	where 
		(KeywordRankingData.Date = @fromDate or KeywordRankingData.Date = @toDate) and
		KeywordRankingData.DomainId in(Select Id from Monitoring_Common_GetDomainIdsOfDomain(default, @domainId))

	order by sk.KeywordValue


Select * from @data

der eine Ausführungszeit von ca. 1 Sekunde hat.

Überführe ich diesen Query in eine UDF mit folgendem Code

ALTER FUNCTION [dbo].[Monitoring_Dashboard_GetRankingData]
(	
	@ProjectId int
)
RETURNS @data TABLE (
   Date   date     NOT NULL,
   KeywordId int NOT NULL,
   KeywordValue nvarchar(max) NOT NULL,
   RankingUrl nvarchar(max) NOT NULL,
   Ranking int      NOT NULL,
   Page int Not Null,
   Competition float NULL,
   AverageMonthlySearches int Not NULL,
   IndexPoints float      NOT NULL
) 
AS
BEGIN

	declare @fromDate date = Convert(date, GETDATE() , 101)
	declare @toDate date = Convert(date, GETDATE() - 7 , 101)
	declare @domainId int 
	Select @domainId = MonitoringModule_DomainId from Projects where id = @ProjectId

	Insert @data
	SELECT KeywordRankingData.Date, sk.KeywordId, sk.KeywordValue, KeywordRankingsUrls.Url, Ranking, Page, COALESCE(sk.Competition, 0), COALESCE(sk.AverageMonthlySearches, 0), (dbo.CalculateIndexPoints(Ranking, AverageMonthlySearches)) 
	from Monitoring_Common_GetSelectedKeywords(@ProjectId) as sk
	Join KeywordRankingData on sk.KeywordId = KeywordRankingData.KeywordId
	Join KeywordRankingsUrls on KeywordRankingData.UrlId = KeywordRankingsUrls.Id

	where 
		(KeywordRankingData.Date = @fromDate or KeywordRankingData.Date = @toDate) and
		KeywordRankingData.DomainId in(Select Id from Monitoring_Common_GetDomainIdsOfDomain(default, @domainId))

	order by sk.KeywordValue

	Return;
END

Ist der Aufruf des query ca. 8 mal langsamer.

Woran liegt so etwas?
Danke euch.

Falls noch jemand das Problem hat:

Hier eine Anleitung zum setzten des Attributes auf Action-Ebene

http://sapoval.org/per-action-custom-sessionstateattribute

Ich glaube ich habe einen Lösungsansatz gefunden.
Es liegt nicht am Browser, sondern am Server, da ASP-MVC bei der Verwendung von Session den gleichzeitigen Zugriff eines Clients blockt.

ASP.NET MVC and Ajax, concurrent requests?

Weiß jemand von euch vielleicht wie man das für jeden Action einzeln ausstellen kann?

Ich hab jetzt

 [SessionState(System.Web.SessionState.SessionStateBehavior.ReadOnly)]

auf alle betroffenen Controller gesetzt, das scheint das Problem größtenteils zu beheben.

Hier ist meine Javascript -Function

function AjaxRequest(url, data, successHandler, silent, reportError) {

    var method = "POST";


    $.ajax({
        type: method,
        contentType: "application/json; charset=utf-8",
        url: url,
        data: data,
        dataType: "json",
        success: function (data) {
            if (successHandler != null) {
                successHandler(data);
            }
        },
        error: function (xhr, status, error) {
            Log("JSON-FEHLER: " + url + " " + data + " " + error);
        }
    });
}

Natürlich läuft der Request asynchron und endet irgendwann im callback,
das Problem ist nur, das mein Browser keinen zweiten ajax-Request lossendet, sobald der erste nicht wieder da ist.

Hi Leute,
ich rufe im Browser einen Ajax-Request auf, wo die HTTP-Response ca. 10 Sekunden dauert. Das Problem ist, dass ich während dieser "Wartezeit" quasi keine anderen Ajax-Calls machen kann, da sie blockieren, bis der erste durch ist.

Ist das normal? ich helfe mir zur Zeit mit getriggerten Statusprüfungen weiter, aber das ist mega unelegant zu programmieren.

Wie geht ihr bei sowas vor ?

verwendetes Datenbanksystem: MSSQL

Hallo zusammen,
ich verwende bei einem Webprojekt einen SQL-Server von Microsoft, der direkt mit der ASP MVC Application auf meinem Server läuft.
Nun besteht der Bedarf, den SQL-Server auch von außen ansprechen zu können.
Ist dies generell möglich? Muss ich hierzu nur die entsprechenden Ports an der Firewall freigeben?
Wie sieht es dann mit der Sicherheit des SQL-Server aus?
Kann man so etwas machen, wenn man sichere Passwörter verwendet, oder sind die Sicherheitslücken zu groß?

Danke euch

Mein oben genanter Ansatz funktioniert bis dato ganz gut.
Ich habe eine Art Mini-Cache implementiert. Das war manuell möglich, da nur eine Entity-Art gecached werden muss.

Ich lasse zur Zeit auch Datenbankzugriffe in verschiedenen Threads laufen, wobei jeder Thread einen eigenen Kontext hat. Mit dem lock - Pattern schließe ich gleichzeitige Zugriffe aus.
Klappt bisher auch hervorragend. Seht ihr hierbei Probleme ?

Ja, ich merke zur Zeit auch, wie ich mir immer wieder über StoredProcedures helfen muss, gerade wenn es darum geht, viele Datenobjekte in einzelnen Properties zu verändern.

Aber nochmal zurück zu meinem Caching-Problem. Was haltet ihr von folgender Strategie:

1. Ich lade die Entities aus dem Context in den Cache und Schließe danach den Context.
2. Die Entities die sich nun "detached" im Context befinden, werden nun ab und an verändert (ohne attached zu sein)
3. Ab und an, prüfe ich, welche Entities sich verändert haben, lade diese in einen neuen Context (attach) und submitte.

?

Okay, vielleicht kannst du mir dann andersweitig helfen:

Meine Performanceprobleme rühren daher, dass ich bei jedem Arbeitsschritt sehr viele Objekte aus der Datenbank benötigte, die ich überprüfen muss. Diese Menge an Objekten ähnelt sich und einzelne Objekte müssen ab und an mal verändert werden.

Wenn ich nun bei jedem Arbeitsschritt, alle nötigen Objekte aus der Datenbank lade, dauert es sehr lange. Meine bisherige Lösung ist, alle geladenen Objekte zu cachen. Hierdurch habe ich einen enormen Geschwindigkeitsvorteil.

Was würdest du vorschlagen?

Ich kann in meiner Architektur nicht immer den DB-Context neu öffnen, sondern muss in teilweise offen halten. Andernfalls bekomme ich sehr starke Performance-Probleme.

Ja, genau das ist ja mein Anliegen.

Ich will alle DB/EF-Aktionen in einem separaten Thread laufen lassen und dass soll immer der gleiche Thread sein. Ich müsste nur wissen, wie ich diesen Thread speicher und bei Bedarf wieder hervorhole.

Den UI-Thread kann ich mir ja über eine Dispatcher-Variable speichern. Geht sowas auch mit anderen threads?

Hallo zusammen,

wie ihr ja sicher wisst, macht das EF Probleme, wenn man Operationen in verschiedenen Threads ausführt.
Meine Idee ist nun, dass ich einen eigenen separaten Thread erstellen, der nur für Operationen des EF zuständig ist. Alle Methoden, die auf die DB über das EF zugreifen sollen an diesen Thread delegiert werden.

Hat jemand eine Idee, wie man sowas realisieren könnte?

Also einer meiner Ansätze wäre es, beide Bilder erstmal sehr stark zu reduzieren.

Danach würde ich dann aus der Gesamtfläche "Kanidaten" auswählen, die passen könnten. Diese "Kanditaten" würde ich dann detaillierter vergleichen und die Reduzierung des Bildes immer weiter herrausnehmen, bis ich ein sicheres Match habe.

@Lenny: das sieht schonmal recht cool aus

Eigentlich nicht.

Stell dir einfach vor, du hast ein Gesamtbild und machst dann mit einer Kamera ein Bild von einem Ausschnitt des Bildes. Die Lage aus der Fotografiert wird ist die gleich wie die aus der das Gesamtbild aufgenommen wurde (parallel zur Bildebene), der Winkel jedoch nicht unbedingt.

Das bringt mich nicht wirklich weiter.
Die Bilder sind auch nicht "digital" gleich, sonder nur "analog" gleich.
Also 2 Aufnahmen.

Hi zusammen,

gibt es einen bekannten Algorithmus, um die Position eine Bildausschnittes in einem Gesamtbild zu ermitteln ?
Der Bildausschnitt ist hierbei in einem beliebigen Lage aufgenommen, was somit heißt, dass nicht vorrausgesetzt werden kann, dass Bild und Bildausschnitt die gleich horizontale Lage haben.

Danke und Gruß

Damit komm ich auf einen "zusätzlichen" Speicherbedarf von ca. 1,5 GB (plus das, was die BLOBs tatsächlich benötigen - aber das brauchst Du ja in beiden Varianten)... Stellt das wirklich ein Problem dar? Das ist in meiner täglichen Arbeit eher zu vernachlässigen - aber das mag natürlich in Deinem Anwendungsfall anders sein...

Nein, das stellt kein Problem dar, ich habe 1TB für die DB eingeplant.
Von daher werde ich deinem Rat folgen und die beiden Tabellen zusammenführen.

Danke nochmal für die Hilfe!

@Bart Simpsons:

Also aktuelle rechne ich mit ca. 10 Mio Datensätzen.
Weißt du wie sich der SQL-Server bezüglich der NULL(able) Datensätze verhält?
Reserviert er hierfür überhaupt irgendwas an Speicher?

Ich habe gerade mal ein paar Felder der Ursprünglichen Tabelle hinzugefügt. Der Speicherplatzverbrauch im Management-Studio ist hierdurch allerdings für die benötigen Datenspeicher geringer(!) geworden. Ich denke jedoch, dass er die Neustrukturierung ebenfalls zur Speicheroptimierung genutzt hat und der Wert daher nicht wirklich aussagekräftig ist.

Danke & Gruß

@bb1898: Das ist generell der Fall, bzw. muss in der Anwendung bis dato eh schon untersucht werden.

@Bart Simpson

Vielen Dank für deine Hilfe, dass Statement für die "optionale" Table sieht wie folgt aus:

CREATE TABLE [dbo].[OnPagePages](
	[Id] [int] IDENTITY(1,1) NOT NULL,
	[UrlId] [int] NOT NULL,
	[Title] [nvarchar](max) NULL,
	[TitleLength] [int] NULL,
	[TitleWidth] [int] NULL,
	[Description] [nvarchar](max) NULL,
	[DescriptionType] [nvarchar](max) NULL,
	[DescriptionLength] [int] NULL,
	[SizeInBytesAggregated] [int] NULL,
	[NumberOfWords] [int] NULL,
	[NumberOfDifferentWordsWithoutStopwords] [int] NULL,
	[TextToCodeRatio] [float] NULL,
	[NumberOfExternalCssFiles] [int] NULL,
	[NumberOfExternalJavascriptFiles] [int] NULL,
	[CanonicalPageId] [int] NULL,
	[CanonicalEqualityTypeId] [int] NULL,
	[PageRank] [float] NULL,
	[RobotsFollow] [bit] NULL,
	[RobotsIndex] [bit] NULL,
	[Language] [nvarchar](max) NULL,
	[Author] [nvarchar](max) NULL,
	[NumberOfH1] [int] NULL,
	[NumberOfH2] [int] NULL,
	[NumberOfH3] [int] NULL,
	[NumberOfH4] [int] NULL,
	[NumberOfH5] [int] NULL,
	[NumberOfH6] [int] NULL,
	[NumberOfJavascriptBlocks] [int] NULL,
	[NumberOfCssBlocks] [int] NULL,
	[NumberOfImages] [int] NULL,
	[NumberOfOutgoingLinks] [int] NULL,
	[NumberOfOutgoingExternalLinks] [int] NULL,
	[NumberOfOutgoingBrokenLinks] [int] NULL,
	[NumberOfOutgoingNoFollowLinks] [int] NULL,
	[NumberOfOutgoingInternalNoFollowLinks] [int] NULL,
	[NumberOfOutgoingExternalFollowLinks] [int] NULL,
 CONSTRAINT [PK_OnPagePage] 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] TEXTIMAGE_ON [PRIMARY]

verwendetes Datenbanksystem: MSSQL

Hallo zusammen,
ich habe eine Datenbankstruktur, in welcher ich eine Tabelle habe, in der ziemlich viele Daten optional sind.
Daher habe ich beim ursprünlichen Design der Datenbank, die optionalen Daten in eine andere Tabelle ausgelagert. Es besteht zwischen den beiden Tabellen nun eine 1 zu {0,1} - Verknüpfung.

Nun ist es jedoch sehr nervig, die Tabellen immer zu joinen und ich überlege, ob ich die optionalen Daten nicht mit in die ursprüngliche Tabelle mit aufnehme. Zusätzlich denke ich, dass ich durch den nicht mehr benötigten Join vielleicht etwas Geschwindigkeit gewinnen könnte.

Meine Fragen sind nun:
Was sprich generell dafür/dagegen?
Wie hoch ist der zusätzliche Speicherbedarf für einen Eintrag in der Tabelle, wenn die optionalen Felder gar nicht belegt werden (NULL sind).

Danke und Gruß

Das Sortieren nach Datum würde wieder in einer nachfolgenden Iteration durch alle Elemente enden. Es kann ja sein, dass ein Objekt in letzter Zeit sehr oft geändert wurde und ein anderes die letzte Änderung vor 2 Wochen hatte.

Hierbei wäre die Selektion der Objekte, die das gleiche Objekt betreffen, aber zeitlich früher stattfanden überflüssig, da ja nur die zeitlich erste Änderungen zum jeweiligen Objekt interessant ist.

Gruß

Bisher nur clientseitige Itterationen, aber die sind viel zu langsam.

Zurzeit überlege ich, ob ich ein zusätzliches Feld "IsLastEntry" einfüge, um mir die Sortierung zu sparen. Aber das erscheint mich auch irgendwie nicht die saubere Lösung.

Gruß

verwendetes Datenbanksystem: SQL

Hi Leute,
ich habe folgende Aufgabe zu lösen.
Ich habe eine Datenbanktabelle, in der alle Änderungen an Objekten notiert werden.
Hierbei wird der Eintrag jeweils mit einem Datum versehen und mit einer ID, welches Objekt betroffen ist und einer weiteren ID um welche Art von Eintrag es sich handelt (TypeId).

Ich will nun die letzten Änderungen für jedes Objekt und jeden Typ ermitteln.
Wie mache ich das am geschicktesten/performantesten ?

Danke und Gruß

Hallo zusammen,

ich bastel zurzeit gerade einen Web-Crawler, der mir Webseiten komplett durchsucht. Die Vorgehensweise ist dabei ähnlich des Google-Bots.
Ich verfolge also so lange Links weiter, bis ich alle URLs der gleichen Domain einmal analysiert habe.

Mein Problem:
Es gibt einige Webseiten (z.B. Shopsysteme), die bei bestimmten Aktionen Session-IDs erzeugen und diese Session IDs dann an jede Url dranhängen. Dies führt teilweise bei einem Crawling zu einer unendlichen Anzahl von URLs (z.B. da bei einer Aktion immer eine neue Session-Id generiert wird).

Hat jemand von euch eine Idee, was ich tun kann um solche Endlosschleifen zu vermeiden? Leider ist es mir nicht möglich beim Crawling Cookies zu akzeptieren und somit das anhängen von Session-Ids zu verhindern.

Vielen Dank für eure Hilfe!

Super, vielen Dank für die schnelle Antwort!

Hallo zusammen,

ich bin zur Zeit an einer Anwendung, die sehr viele Daten via HTTP-Post sendet.
Normalerweise ist die Kommunikation zwischen Client und Server ja so, dass der Client sagt, was er als Kompression akzeptiert ("Acccept-Encoding: gzip") und der Server (wenn er kann) entsprechendes im Response zur Verfügung stellt ("Content-Encoding: gzip").

Da die meisten GET-Request ja sehr klein sind benötigen Sie keine Kompression, bei großen Daten via POST kann das jedoch anders sein.

Vom Konzept her macht es jedoch wenig Sinn, komprimierte Daten via POST zu übertragen, da der Client ja gar nicht wissen kann, ob der Server diese Komprimierung versteht.

Weiß jemand, wie man so eine Situation am elegantesten bewerkstelligt?

Über das Object SqlConnection 😄

Mittlerweile habe ich festgestellt, dass viele Queries, die ich direkt über das SSMS laufen lasse bei weitem schneller sind als wenn ich sie über das Programm ablaufen lasse.

Dabei ist es egal, ob ich das EF nutze oder eine Verbindung via SqlConnection aufbaue. Es handelt sich dabei auch nicht um kleine Differenzen, sondern um Unterschiede im Bereich des 100 bis 1000 fachen!!!.

Komischerweise kommt es auch darauf an, wie der Query an sich aussieht (siehe meine vorherige Problembeschreibung.)

Weiß irgendjemand was man tun kann?

Also,

das generierte SQL ist in Fall 1 (anonymer Typ, langsamer Fall ca. 15 Sekunden)

SELECT TOP (25) 
    [Project1].[Id] AS [Id], 
    [Project1].[Url] AS [Url]
    FROM ( SELECT [Project1].[Id] AS [Id], [Project1].[Url] AS [Url], row_number() OVER (ORDER BY [Project1].[Id] ASC) AS [row_number]
        FROM ( SELECT 
            [Extent1].[Id] AS [Id], 
            [Extent2].[Url] AS [Url]
            FROM  [dbo].[OnPagePages] AS [Extent1]
            INNER JOIN [dbo].[OnPageUrls] AS [Extent2] ON [Extent1].[UrlId] = [Extent2].[Id]
            WHERE ([Extent2].[PassthroughId] = @p__linq__0) AND (2 = [Extent2].[StateId])
        )  AS [Project1]
    )  AS [Project1]
    WHERE [Project1].[row_number] > 1000
    ORDER BY [Project1].[Id] ASC

Im anderen Fall (gesamten Entity, ca. 2 Sekunden)

SELECT TOP (25) 
    [Project1].[Id1] AS [Id], 
    [Project1].[StateId] AS [StateId], 
    [Project1].[Url] AS [Url], 
    [Project1].[PassthroughId] AS [PassthroughId], 
    [Project1].[Internal] AS [Internal], 
    [Project1].[HttpStatusCode] AS [HttpStatusCode], 
    [Project1].[LoadingSpeedInMilliseconds] AS [LoadingSpeedInMilliseconds], 
    [Project1].[TimeToFirstByteInMilliseconds] AS [TimeToFirstByteInMilliseconds], 
    [Project1].[Content] AS [Content], 
    [Project1].[ContentTypeId] AS [ContentTypeId], 
    [Project1].[ContentEncoding] AS [ContentEncoding], 
    [Project1].[SizeInBytes] AS [SizeInBytes], 
    [Project1].[SizeInBytesDecompressed] AS [SizeInBytesDecompressed], 
    [Project1].[IsHeaderRedirect] AS [IsHeaderRedirect], 
    [Project1].[HeaderRedirectTargetUrl] AS [HeaderRedirectTargetUrl], 
    [Project1].[ContentLanguage] AS [ContentLanguage], 
    [Project1].[UrlInvalidCharacters] AS [UrlInvalidCharacters], 
    [Project1].[UrlFolderDeepth] AS [UrlFolderDeepth], 
    [Project1].[UrlNumberOfGetParameters] AS [UrlNumberOfGetParameters], 
    [Project1].[UrlUpperAndLowerCaseCombined] AS [UrlUpperAndLowerCaseCombined], 
    [Project1].[UrlLength] AS [UrlLength], 
    [Project1].[ClickPathLength] AS [ClickPathLength], 
    [Project1].[UrlMd5] AS [UrlMd5]
    FROM ( SELECT [Project1].[Id] AS [Id], [Project1].[Id1] AS [Id1], [Project1].[StateId] AS [StateId], [Project1].[Url] AS [Url], [Project1].[PassthroughId] AS [PassthroughId], [Project1].[Internal] AS [Internal], [Project1].[HttpStatusCode] AS [HttpStatusCode], [Project1].[LoadingSpeedInMilliseconds] AS [LoadingSpeedInMilliseconds], [Project1].[TimeToFirstByteInMilliseconds] AS [TimeToFirstByteInMilliseconds], [Project1].[Content] AS [Content], [Project1].[ContentTypeId] AS [ContentTypeId], [Project1].[ContentEncoding] AS [ContentEncoding], [Project1].[SizeInBytes] AS [SizeInBytes], [Project1].[SizeInBytesDecompressed] AS [SizeInBytesDecompressed], [Project1].[IsHeaderRedirect] AS [IsHeaderRedirect], [Project1].[HeaderRedirectTargetUrl] AS [HeaderRedirectTargetUrl], [Project1].[ContentLanguage] AS [ContentLanguage], [Project1].[UrlInvalidCharacters] AS [UrlInvalidCharacters], [Project1].[UrlFolderDeepth] AS [UrlFolderDeepth], [Project1].[UrlNumberOfGetParameters] AS [UrlNumberOfGetParameters], [Project1].[UrlUpperAndLowerCaseCombined] AS [UrlUpperAndLowerCaseCombined], [Project1].[UrlLength] AS [UrlLength], [Project1].[ClickPathLength] AS [ClickPathLength], [Project1].[UrlMd5] AS [UrlMd5], row_number() OVER (ORDER BY [Project1].[Id] ASC) AS [row_number]
        FROM ( SELECT 
            [Extent1].[Id] AS [Id], 
            [Extent2].[Id] AS [Id1], 
            [Extent2].[StateId] AS [StateId], 
            [Extent2].[Url] AS [Url], 
            [Extent2].[PassthroughId] AS [PassthroughId], 
            [Extent2].[Internal] AS [Internal], 
            [Extent2].[HttpStatusCode] AS [HttpStatusCode], 
            [Extent2].[LoadingSpeedInMilliseconds] AS [LoadingSpeedInMilliseconds], 
            [Extent2].[TimeToFirstByteInMilliseconds] AS [TimeToFirstByteInMilliseconds], 
            [Extent2].[Content] AS [Content], 
            [Extent2].[ContentTypeId] AS [ContentTypeId], 
            [Extent2].[ContentEncoding] AS [ContentEncoding], 
            [Extent2].[SizeInBytes] AS [SizeInBytes], 
            [Extent2].[SizeInBytesDecompressed] AS [SizeInBytesDecompressed], 
            [Extent2].[IsHeaderRedirect] AS [IsHeaderRedirect], 
            [Extent2].[HeaderRedirectTargetUrl] AS [HeaderRedirectTargetUrl], 
            [Extent2].[ContentLanguage] AS [ContentLanguage], 
            [Extent2].[UrlInvalidCharacters] AS [UrlInvalidCharacters], 
            [Extent2].[UrlFolderDeepth] AS [UrlFolderDeepth], 
            [Extent2].[UrlNumberOfGetParameters] AS [UrlNumberOfGetParameters], 
            [Extent2].[UrlUpperAndLowerCaseCombined] AS [UrlUpperAndLowerCaseCombined], 
            [Extent2].[UrlLength] AS [UrlLength], 
            [Extent2].[ClickPathLength] AS [ClickPathLength], 
            [Extent2].[UrlMd5] AS [UrlMd5]
            FROM  [dbo].[OnPagePages] AS [Extent1]
            INNER JOIN [dbo].[OnPageUrls] AS [Extent2] ON [Extent1].[UrlId] = [Extent2].[Id]
            WHERE ([Extent2].[PassthroughId] = @p__linq__0) AND (2 = [Extent2].[StateId])
        )  AS [Project1]
    )  AS [Project1]
    WHERE [Project1].[row_number] > 1000
    ORDER BY [Project1].[Id] ASC

Es ist also quasi die gleiche Codestruktur, nur das beim zweiten Statement mehr selektiert wird.
Führe ich beide Statements im SQL-Server-Management-Studio aus, so erreiche ich eine Laufzeit von < 200ms !!

Jemand eine Idee?

Ich habe das Problem jetzt weiter untersucht.

Ich benutzt das Entity - Framework - 6.0

Letztendlich ließ sich das Problem auf folgenden (mir nicht erklärbaren) Fall reduzieren:

Folgende Abfrage ist einigermaßen performant (ca. 2 Sekunden):

            var testPages2 = (from p in db.OnPagePages
                              join u in db.OnPageUrls on p.UrlId equals u.Id
                              where u.PassthroughId == lastPassthrough.Id && u.StateId == 2
                              orderby p.Id
                              select  u
                             ).Skip(1000).Take(25);

während folgende Abfrage sehr unperformant ist (ca. 15 Sekunden):

            var testPages2 = (from p in db.OnPagePages
                              join u in db.OnPageUrls on p.UrlId equals u.Id
                              where u.PassthroughId == lastPassthrough.Id && u.StateId == 2
                              orderby p.Id
                              select  new
                            {
                                url = u.Url,
                                contentEncoding = u.ContentEncoding
                            }

                             ).Skip(1000).Take(25);

Das Problem tritt übrigens nur auf, wenn die im anonymen Typ verwendeten Propertys Strings sind.

Hat jemand eine Idee, warum das so ist?

verwendetes Datenbanksystem: MSSQL-Linq

Hallo zusammen,
ich verwende in meine ASP MVC 4.0 Webprojekt LINQ um die Datenbank abzufragen.
Einige LINQ-Anfragen dauern sehr, sehr lange, wenn sie ausgeführt werden (bis zu einer Minute).

Mein bisheriger Ansatz war, mir über [query].ToString() das SQL ausgeben zu lassen und es mit dem SQL-Server-Management-Studio zu testen.

Nun ist es jedoch des öfteren so, dass das zu Grunde liegende SQL überhaupt keine Performance-Probleme hat (und innerhalb weniger Millisekunden ausgeführt wird).

Weiß jemand von euch, woran das liegen könnte?

Vielen Dank

Hallo zusammen,

ich möchte den reinen Text aus einem HTML-Sourcecode erhalten.

Hat jemand eine Idee, wie ich am besten vorgehe und was ich alles entfernen muss?

Danke.

ja okay, das macht generell Sinn, aber es ist letztendlich nicht der Performance-Killer im aktuellen Fall.

Die gleiche Meldung bezüglich des Index erscheint allerdings auch bei den Abfragen die performant laufen.

Der Query Analyzer meldet:

/*
Fehlende Indexdetails von SQLQuery2.sql - (local)\TEW_SQLEXPRESS.PageRangers (Office-PC\Administrator (53))
Der Abfrageprozessor schätzt, dass durch das Implementieren des folgenden Indexes die Abfragekosten um 96.5767 % verbessert werden können.
\*/

/*
USE [PageRangers]
GO
CREATE NONCLUSTERED INDEX [<Name of Missing Index, sysname,>]
ON [dbo].[KeywordPassthroughRankings] ([DomainId])
INCLUDE ([Id],[Page],[Ranking],[PassthroughId],[UrlId])
GO
\*/

und hat den angehängten Ausführungsplan. Allerdings bin ich nicht wirklich in der Lage mit den Meldungen was anzufangen.

Kann mir jemand helfen?

Hier noch einmal zur Verdeutlichung:

Folgender Code läuft nicht performant:

Select * from RankingPassthroughs
Inner Join KeywordPassthroughs on RankingPassthroughs.Id = KeywordPassthroughs.RankingPassthroughId
Inner Join KeywordPassthroughRankings on KeywordPassthroughRankings.PassthroughId = KeywordPassthroughs.Id
Inner Join KeywordRankingsUrls on KeywordPassthroughRankings.UrlId = KeywordRankingsUrls.Id
Inner Join Keywords on KeywordPassthroughs.KeywordId = Keywords.Id
where KeywordPassthroughRankings.DomainId = 88

während sowohl

Select * from RankingPassthroughs
Inner Join KeywordPassthroughs on RankingPassthroughs.Id = KeywordPassthroughs.RankingPassthroughId
Inner Join KeywordPassthroughRankings on KeywordPassthroughRankings.PassthroughId = KeywordPassthroughs.Id
Inner Join Keywords on KeywordPassthroughs.KeywordId = Keywords.Id
where KeywordPassthroughRankings.DomainId = 88

als auch

Select * from RankingPassthroughs
Inner Join KeywordPassthroughs on RankingPassthroughs.Id = KeywordPassthroughs.RankingPassthroughId
Inner Join KeywordPassthroughRankings on KeywordPassthroughRankings.PassthroughId = KeywordPassthroughs.Id
Inner Join KeywordRankingsUrls on KeywordPassthroughRankings.UrlId = KeywordRankingsUrls.Id
where KeywordPassthroughRankings.DomainId = 88

performant laufen.