Was ist der effizienteste Weg, um den Zugriff auf den Wert eines Feldes in ein ADO-recordset?

Ich habe eine VB6-Anwendung vor mir, die Zugriff auf Sql-Datenbanken über ADO.

Beim abrufen von recordsets, die Anwendung verwendet das Ausrufezeichen (!) Operatoren zum Zugriff auf die Felder des recordsets Eg RS!Bestell-NR.

Während ich mir bewusst bin von dieser Praxis habe ich eigentlich nie genutzt(außer, wenn ich faul gewesen), Weder habe ich RS("OrderId"), wie ich immer (oder meistens) verwendet werden, der vollständig qualifizierte Versandart (z.B. RS.Felder("OrderId").Wert. oder baute Sie noch weiter mit dem .Item-Eigenschaft.)

Beide geben genau die gleichen Wert kürzer ist, zu geben als die anderen.

Den Grund habe ich klebte an dieser Methode ist, dass irgendwann in der Fernen Vergangenheit, ich glaube, ich wurde gesagt, es war mehr performant voll qualifizieren, das Feld, da war der code übersetzt wird jedes auftreten der ! operator, um den vollständig qualifizierten Schwester. Allerdings, die ! operator reduziert sich auf die Eingabe und als solche dev Zeit.

Auch ich scheine zu erinnern, dass die ! für ADO war veraltet, der irgendwann in der Zukunft. Aber es scheint immer noch zu sein, um im code ich habe nur gefragt, welche Methode gilt als best-practice-und die führt man besser über den anderen.

Alle VB6 ist mehr oder weniger veraltet, nicht? Der Bang-operator wird nicht unterstützt .NET
Die meisten performant sind die ordinalen Methoden; rs(index) oder die (versteckten) Namen nennen, rs.sammeln Sie(index), da Sie beide vermeiden die späte Bindung overhead ! und der key lookup-das ist erforderlich, wenn Sie einen Feldnamen verwenden
Wenn Sie das abrufen der gesamte recordset und nicht schreiben, würde ich denken, es schnellsten GetRows().

InformationsquelleAutor BrianBurkill | 2014-02-03

ado vb6

6

Ich gründlich getestet, die Leistung von VB6 und ADO für den Einsatz in meiner Anwendung. Die absolute Schnellste Weg, um Daten aus einem recordset zu verwenden, das FIELD-Objekt. Sie werden bemerken einen großen Unterschied in der Leistung bei der Rückkehr eine Menge von Zeilen. Das folgende ist ein block von code aus meiner Anwendung (ermäßigt markieren Sie die richtige Verwendung von Feld-Objekte).
```
Dim fMinLongitude As ADODB.Field
Dim fMinLatitude As ADODB.Field
Dim fMaxLongitude As ADODB.Field
Dim fMaxLatitude As ADODB.Field
Dim fStreetCount As ADODB.Field

If RS.RecordCount = 0 Then
    Exit Sub
End If

Set fMinLongitude = RS.Fields.Item("MinLongitude")
Set fMinLatitude = RS.Fields.Item("MinLatitude")
Set fMaxLongitude = RS.Fields.Item("MaxLongitude")
Set fMaxLatitude = RS.Fields.Item("MaxLatitude")
Set fStreetCount = RS.Fields.Item("StreetCount")

While Not RS.EOF
    LineGridCount = LineGridCount + 1
    With LineGrid(LineGridCount)
        .MinLongitude = fMinLongitude.Value
        .MaxLongitude = fMaxLongitude.Value
        .MinLatitude = fMinLatitude.Value
        .MaxLatitude = fMaxLatitude.Value
    End With
    RS.MoveNext

Wend

RS.Close
Set RS = Nothing
```
Hinweis, dass ich einen Feld-Objekte für 5 Spalten zurückgegeben, die von einer gespeicherten Prozedur von SQL Server. Ich habe dann mit Ihnen in einer Schleife. Wenn Sie RS.MoveNext, es wirkt sich auf die Feld-Objekte.

Mit dem code oben, ich kann die Last von 26.000 Zeilen in mein Benutzer-definierter Typ ist in weniger als 1 Sekunde. In der Tat läuft durch code es dauerte 0,05 Sekunden. In der kompilierten Anwendung ist es sogar noch schneller.

Wenn Sie nicht mit der Feld-Objekte, dann sollten Sie zumindest einen WITH-block. Wie bereits in einem anderen Beitrag, mit Ordnungszahl ist schneller als die andere alternative (mit Ausnahme des field-Methode). Wenn Sie planen, Ordnungszahl, dann sollten Sie einen WITH-block. Zum Beispiel:
```
With RS.Fields
  ID = .Item(0).Value
  Name = .Item(1).Value
  EyeColor = .Item(2).Value
End With
```
Mit einem with-block ist gut, denn es reduziert den Betrag eingeben, und gleichzeitig beschleunigt es die Ausführung von code. Diese Erhöhung der Leistung tritt auf, weil VB kann ein Zeiger auf das Feld Objekt einmal und dann die Wiederverwendung, die Zeiger für jeden Aufruf der Felder Objekt.

By the way... ich mag die "weniger eingeben" - argument. Oft finde ich, dass die bessere Leistung code ist auch komplexeren code. Mit VB6 intellisense, die extra Eingabe ist nicht alles, viel.

RS("Feldname") ist auf 15 Zeichen.

Ich habe bekommen in die Gewohnheit der Eingabe von: r s - (dot) - f (dot) i (offene Klammer) (Zitat) FieldName (Zitat) (schließende Klammer) (Punkt) v. Dies ist 6 zusätzliche Taste drückt, die für die Verwendung der voll qualifizierte Methode.

Mithilfe der with-block-Methode, wäre es (Punkt) i (offene Klammer) (Zitat) FieldName (Zitat) (schließende Klammer) (Punkt) v, 17-Taste drückt.

Dies ist eine jener Situationen, in denen eine gute Gewohnheit nimmt wenig Aufwand und zahlt sich aus groß durch die bessere Leistung code.

Habe ich nur einige performance-Tests. Der folgende test verwendet einen client-cursor, was bedeutet, dass alle Daten von der Abfrage zurückgegeben wird an den Clientcomputer kopiert und gespeichert, die innerhalb des recordset-Objekts.

Den code, den ich verwendet für den performance-test ist dieser:
```
Private Sub Command1_Click()

    Dim DB As ADODB.Connection
    Dim RS As ADODB.Recordset
    Dim Results() As String

    Set DB = New ADODB.Connection
    DB.ConnectionString = "my connection string here"
    DB.CursorLocation = adUseClient
    DB.Open

    Set RS = New ADODB.Recordset
    Call RS.Open("Select * From MapStreetsPoints", DB, adOpenForwardOnly, adLockReadOnly)

    Dim Start As Single
    Dim FeatureId As Long
    Dim PointNumber As Long
    Dim Longitude As Single
    Dim Latitude As Single
    Dim fFeatureId As ADODB.Field
    Dim fPointNumber As ADODB.Field
    Dim fLongitude As ADODB.Field
    Dim fLatitude As ADODB.Field

    ReDim Results(5)

    RS.MoveFirst
    Start = Timer
    Do While Not RS.EOF
        FeatureId = RS!FeatureId
        PointNumber = RS!PointNumber
        Longitude = RS!Longitude
        Latitude = RS!Latitude
        RS.MoveNext
    Loop
    Results(0) = "Bang Method: " & Format(Timer - Start, "0.000")

    RS.MoveFirst
    Start = Timer
    Do While Not RS.EOF
        FeatureId = RS.Fields.Item("FeatureId").Value
        PointNumber = RS.Fields.Item("PointNumber").Value
        Longitude = RS.Fields.Item("Longitude").Value
        Latitude = RS.Fields.Item("Latitude").Value
        RS.MoveNext
    Loop
    Results(1) = "Fully Qualified Name Method: " & Format(Timer - Start, "0.000")

    RS.MoveFirst
    Start = Timer
    Do While Not RS.EOF
        FeatureId = RS.Fields.Item(0).Value
        PointNumber = RS.Fields.Item(1).Value
        Longitude = RS.Fields.Item(2).Value
        Latitude = RS.Fields.Item(3).Value
        RS.MoveNext
    Loop
    Results(2) = "Fully Qualified Ordinal Method: " & Format(Timer - Start, "0.000")

    RS.MoveFirst
    Start = Timer
    With RS.Fields
        Do While Not RS.EOF
            FeatureId = .Item("FeatureId").Value
            PointNumber = .Item("PointNumber").Value
            Longitude = .Item("Longitude").Value
            Latitude = .Item("Latitude").Value
            RS.MoveNext
        Loop
    End With
    Results(3) = "With Block Method: " & Format(Timer - Start, "0.000")

    RS.MoveFirst
    Start = Timer
    With RS.Fields
        Do While Not RS.EOF
            FeatureId = .Item(0).Value
            PointNumber = .Item(1).Value
            Longitude = .Item(2).Value
            Latitude = .Item(3).Value
            RS.MoveNext
        Loop
    End With
    Results(4) = "With Block Ordinal Method: " & Format(Timer - Start, "0.000")

    RS.MoveFirst
    Start = Timer
    Set fFeatureId = RS.Fields.Item("FeatureId")
    Set fPointNumber = RS.Fields.Item("PointNumber")
    Set fLatitude = RS.Fields.Item("Latitude")
    Set fLongitude = RS.Fields.Item("Longitude")
    Do While Not RS.EOF
        FeatureId = fFeatureId.Value
        PointNumber = fPointNumber.Value
        Longitude = fLongitude.Value
        Latitude = fLatitude.Value
        RS.MoveNext
    Loop
    Results(5) = "Field Method: " & Format(Timer - Start, "0.000")

    Text1.Text = "Rows = " & RS.RecordCount & vbCrLf & Join(Results, vbCrLf)

End Sub
```
Sind die Ergebnisse:
```
Rows = 2,775,548

Bang Method: 9.441
Fully Qualified Name Method: 9.367
Fully Qualified Ordinal Method: 5.191
With Block Method: 8.527
With Block Ordinal Method: 5.117
Field Method: 4.316
```
Klar das Feld Methode ist der Gewinner. Es dauert weniger als 1/2 die Zeit der bang-Methode. Beachten Sie auch, dass die Ordnungszahl Methoden haben auch anständige Leistung im Vergleich zu Feld-Methode.

Allerdings rs!fieldname (auch ohne Anhängen .Wert) beträgt nur etwa 40% schlechter als rs.Fields.Item(index).Value, und es ist 40% mehr von eine eher kleine Menge von CPU-Zeit. Ich Frage nicht den Wert der optimalen Gewohnheiten, die Gewinne aber kann ziemlich winzig, in der Größenordnung von 1,5 Sekunden oder weniger für 1 Millionen Zeilen.
der Punkt, den ich versuche zu vermitteln ist, dass MIT blocks haben einen großen Einfluss auf die performance. Wenn eine person nicht bereit zu gehen durch den Aufwand der Verwendung von ADODB.Felder, als Sie sollten mindestens die Verwendung MIT dem blocks-und die Ordinalzahlen. Außerdem kleine Mengen an CPU-Zeit kann zu großen Verzögerungen für die Nutzer und eine träge app.
Ich Stimme alle Ihre Punkte, das ist der Grund, warum ich habe deine Antwort oben. Ich habe gerade nicht einverstanden, dass diese Art der Optimierung macht einen großen Unterschied in den meisten Programmen... wenn die Zwischenspeicherung stark verwendet Objekt-Referenzen (explizit oder per Mit) erhalten Sie die die meisten "bang" für die Mühe. Beachten Sie, dass diese auch verwendet werden kann mit der "bang" - syntax, so wie .Value können.
Ich mag die "Felder" - Methode, aber ich Steuere Weg von der Ordinalen Methoden aufgrund einer vergangenen Erfahrung, wenn einer von meinem team RS(0),(1),(2) etc. Es funktionierte gut und wurde gefördert Leben. Eine andere person in ein anderes team entschieden, um die Verwendung genau der gleichen Prozedur (wie er sollte), aber anstelle von Anhängen werden die Felder für die Ausgabe, fügte er Sie, und live einsetzbar. Plötzlich, meine Jungs Anwendung fiel. Ich habe sofort auferlegten Regel immer nur die Felder anfügen der Ausgabe. Aber jemand ignoriert es und es ist wieder passiert, so dass ich verboten die Verwendung von ordinalen Feldern für die explizite Benennung der Methode.
Wieder, die Felder-Methode ist die performant. Wenn man sich an meinem Beispiel, setzen Sie jedes Objekt auf der Basis der Feld-Namen (nicht die Ordnungszahl). Sie effektiv erhalten das beste aus beiden Welten. Sie code haben, der nicht abhängig von der Ordnungszahl und sogar besser abschneidet als die Ordnungszahl Methoden. Im Grunde, es ist schneller und zuverlässiger.

InformationsquelleAutor G Mastros
1

Bill Vaughn hatte eine gute Diskussion dieser in seinem Artikel "ADO-Performance Best Practices". Das Fazit, wie von Alex K in den Kommentar, ist die Verwendung einer ordinalen wie rs(0) oder rs(7).

Bill auch diskutiert, eine Technik der Verwendung von enum zu bieten lesbaren Namen für die index-Positionen. Zum Beispiel mit einer Abfrage wie:
```
SELECT CatName, CatType, CatSize from Cats Where...
```
Haben, könnten Sie diese enum in VB:
```
Enum enuCatsQuery
    CatName
    CatType
    CatSize
End Enum
```
Und diesen code für den Zugriff auf das Feld:
```
StrMyName = Rs(enuCatsQuery.CatName)
```
Ich mag die "Felder" - Methode, aber ich Steuere Weg von der Ordinalen Methoden aufgrund einer vergangenen Erfahrung, wenn einer von meinem team RS(0),(1),(2) etc. Es funktionierte gut und wurde gefördert Leben. Eine andere person in ein anderes team entschieden, um die Verwendung genau der gleichen Prozedur (wie er sollte), aber anstelle von Anhängen werden die Felder für die Ausgabe, fügte er Sie, und live einsetzbar. Plötzlich, meine Jungs Anwendung fiel. Ich habe sofort auferlegten Regel immer nur die Felder anfügen der Ausgabe. Aber jemand ignoriert es und es ist wieder passiert, so dass ich verboten die Verwendung von ordinalen Feldern für die explizite Benennung der Methode.
Ja, das ist sicherlich einer der trade-offs, wie in dem Artikel erwähnt. Ein weiteres Beispiel dafür, wie sich die performance und die Wartbarkeit sind oft im Widerspruch zu einander!

InformationsquelleAutor Holistic Developer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.