Verwendung des ADO-Befehls SHAPE

Wichtig: Dieser Artikel wurde maschinell übersetzt und wird dann möglicherweise mithilfe des Community Translation Framework (CTF) von Mitgliedern unserer Microsoft Community nachbearbeitet. Weitere Informationen zu CTF finden Sie unter http://support.microsoft.com/gp/machine-translation-corrections/de.

Den englischen Originalartikel können Sie über folgenden Link abrufen: 189657
Disclaimer zu nicht mehr gepflegten KB-Inhalten
Dieser Artikel wurde für Produkte verfasst, für die Microsoft keinen Support mehr anbietet. Der Artikel wird deshalb in der vorliegenden Form bereitgestellt und nicht mehr weiter aktualisiert.
Zusammenfassung
Dieser Artikel beschreibt die ADO SHAPE -Befehlssyntax für hierarchische Recordsets erzeugt, und erläutert, wie hierarchische Recordsets durchlaufen. VBA-Beispielcode wird ebenfalls bereitgestellt.
Weitere Informationen
Sie können hierarchische Recordsets als Alternative zur Join- und GROUP BY-Syntax hierarchische und zusammengefasste Daten zugreifen müssen.

Hierarchische Recordsets werden in vielen Produkten verwendet: Xbase-Produkte verwenden den Befehl SET RELATION, Access "Segmentierten intern virtuelle Tabellen" für Berichte mit Gruppierungsebenen usw. verwendet. Hierarchien können Sie eine oder mehrere Recordsets erstellen, definieren Gruppen und aggregate Berechnungen über untergeordneten Recordsets angeben. Obwohl Sie ähnliche Funktionalität mit Code implementieren können, verlagert diese Funktionalität viel Routinearbeit vom Entwickler zum System.

Hierarchische Recordsets stehen über den MSDataShape-Provider von der Client Cursor Engine implementiert wird.

Hierarchische Recordsets unterscheiden sich von SQL JOIN und GROUP BY -Anweisungen, mit einem JOIN, die Felder der übergeordneten Tabelle und Felder der untergeordneten Tabelle im selben Recordset vertreten. Ein hierarchisches Recordset enthält das Recordset nur die Felder der übergeordneten Tabelle. Das Recordset enthält ein zusätzliches Feld, das zweite Recordset-Variable zuweisen und durchlaufen zugehörigen untergeordneten Daten darstellt.

Beim Ausführen von Aggregatfunktionen verwenden Von GROUP BY und Aggregatoperatoren erscheinen nur Aggregatwerte im Recordset. Hierarchische Recordsets werden die Aggregatwerte im übergeordneten Recordset dargestellt und die Detaildatensätze werden im untergeordneten Recordset.

Sie können drei Typen von Shapes erstellen und jeden hat Stärken und Schwächen. Sie müssen das Verfahren auswählen, das am besten geeignete der Anwendung und der Umgebung, die Sie die Anwendung ausgeführt werden. Die Shapes sind wie folgt:
  • Beziehung basiert
  • Parameter basierend
  • Gruppe
Die ersten beiden ähneln sich, da sie eine Hierarchie erzeugen, die sonst durch eine SQL JOIN -Anweisung dargestellt wird. Sie unterscheiden sich in alle gelesenen über- und untergeordneten Datensätzen in einem lokalen Cache vor der Verarbeitung in der relationsbasierten Hierarchie fortgesetzt. Diese Hierarchie hat Anfang eines hohen Aufwand beim Abrufen der Datensätze, aber der Aufwand ist niedrig nach dem abrufen.

Zunächst, parameterbasierte Hierarchien nur die übergeordneten Datensätze und holen die untergeordneten Sätze auf Anforderung. Wenn der anfängliche Aufwand reduziert, muss dafür eine neue Abfrage der untergeordneten für jeden übergeordneten Satz, auf den zugegriffen wird und die Verbindung zur Datenquelle für muss beibehalten werden, solange das Recordset geöffnet ist.

Gruppenbasierte Hierarchie entspricht erzeugt eine aggregate SQL-Anweisung mit einer einzelnen SQL-Anweisung oder dass Aggregatfunktionen nicht normalisierten Daten verbunden. Die Summenspalten und berechneten Spalten nicht aktualisiert werden, da sie mehr als einen Datensatz abgeleitet werden können. Wie relationsbasierten Hierarchien müssen alle Datensätze im Voraus gelesen werden.

Hierarchische Recordsets werden durch die SHAPE -Klausel zur Verfügung gestellt. Vereinfachte Syntax erfolgt dann zunächst Beispiele mit Diagrammen. Da die SHAPE -Syntax recht komplex werden kann, erfolgt die formale Grammatik für die SHAPE-Klausel am Ende des Artikels, der Sie die Beispiele erweitern können. Auch können das Programm am Ende dieses Artikels eigene Form -Anweisung testen. Das Beispiel verwendet Tabellen aus der Northwind-Beispieldatenbank.

Vereinfachte Syntax

   SHAPE {parent-statement}   APPEND Aggregate        | ({child-statement} [As Alias]          RELATE parent-field TO child-field | parameter-marker                 [, parent-field TO child-field | parameter-marker ...])          [, Aggregate | ({child statement})...]   SHAPE {non-normalized-statement} [AS Alias]   COMPUTE Aggregate         | Alias         | ({child-statement} [As Alias] RELATE parent-field TO                                        child-field | parameter-marker)           [, Aggregate | Alias | ({child-statement}...)]   [BY grouping-field [, grouping-field]]   SHAPE {non-normalized-statement} [AS Alias]   BY grouping-field [, grouping-field]				

HINWEISE:

  1. Auswählen von gleichnamigen Felder aus Differenttables Alias möglicherweise sicherzustellen, dass der SHAPE -Parser funktioniert.
  2. Die SHAPE APPEND Funktionsweise einer OUTER JOIN , ein übergeordneten Datensatz zurückgegeben wird, wenn keine untergeordneten Recordsexist dafür.
  3. Aggregate können nur Felder in den Immediatechildren des Recordsets bearbeiten. Um Felder Enkel usw. arbeiten, muss Zwischenaggregate erstellen. Siehe Beispiel WithAggregate Hierarchie am Ende dieses Artikels zur Veranschaulichung.
  4. Wenn Sie eine Aggregatfunktion mit der SHAPE APPEND -Syntax verwenden, belegt der Aggregatwert ein Feld angefügt Theparent Resultset, das auch die Felder aus der übergeordneten Anweisung enthält. Incontrast das SHAPE COMPUTE und SHAPE BY eine neue übergeordnete Ebene für die Aggregate erstellen und Thenon normalisierte Anweisung wird zum untergeordneten Recordset.
  5. SHAPE -Provider erfordert, dass Sie Alias angeben für thon-normalisiert-Anweisung in der COMPUTE -Klausel SHAPE COMPUTEVerwendung. Andernfalls führt eine Nachricht Isnot Funktionen unterstützt, obwohl es einen Syntaxfehler führen nicht.

Beispiele

Einfache Relationshierarchie:

   SHAPE  {select * from customers}   APPEND ({select * from orders} AS rsOrders           RELATE customerid TO customerid)				
Das ergibt:
   Customers.*   rsOrders        |        +----Orders.*				
In diesem Diagramm enthält das übergeordnete Recordset alle Felder aus der Tabelle Customers und ein Feld namens "rsOrders". RsOrders enthält einen Verweis auf das untergeordnete Recordset und enthält alle Felder aus der Tabelle Orders. Die Beispiele verwenden eine ähnliche Notation verwendet.

Parametrisierte Hierarchie:

   SHAPE  {select * from customers}   APPEND ({select * from orders where customerid = ?} AS rsOrders           RELATE customerid TO PARAMETER 0)				
Dies führt in der gleichen Hierarchie wie der einfachen Relationshierarchie.

Zusammengesetzte Relationshierarchie:

Dieses Beispiel zeigt eine Hierarchie mit drei Ebenen von Customers, Orders und Order Details:
   SHAPE  {SELECT * from customers}   APPEND ((SHAPE  {select * from orders}            APPEND ({select * from [order details]} AS rsDetails                   RELATE orderid TO orderid)) AS rsOrders          RELATE customerid TO customerid)				
Das ergibt:
   Customers.*   rsOrders        |        +----Orders.*             rsDetails                 |                 +----[Order Details].*				

Mehrfache Relationshierarchie:

Dieses Beispiel zeigt eine Hierarchie mit einem übergeordneten und zwei untergeordneten Recordsets, von denen eines parametrisiert ist:
   SHAPE  {SELECT * FROM customers}   APPEND ({SELECT *            FROM orders            WHERE orderdate < #1/1/1998# AND customerid = ?}            RELATE customerid TO PARAMETER 0) AS rsOldOrders,          ({SELECT *            FROM orders            WHERE orderdate >= #1/1/1998#}            RELATE customerid TO customerid) AS rsRecentOrders				
Das ergibt:
   Customers.*   rsOldOrders        |        +----Orders.*   rsRecentOrders        |        +----Orders.*				

Hierarchie mit Aggregat:

   SHAPE  (select * from orders}   APPEND ({select od.orderid, od.UnitPrice * od.quantity as ExtendedPrice            from [order details] As od}          RELATE orderid TO orderid) As rsDetails,          SUM(ExtendedPrice) AS OrderTotal				
Das ergibt:
   Orders.*   rsDetails       |       +----orderid            ExtendedPrice   OrderTotal				

Hierarchie:

   SHAPE  {select customers.customerid AS cust_id, orders.*           from customers inner join orders           on customers.customerid = orders.customerid} AS rsOrders   COMPUTE rsOrders BY cust_id				
Das ergibt:
   rsOrders       |       +----cust_id            Orders.*   cust_id				

Gruppenhierarchie mit Aggregat:

Hinweis: die innere SHAPE-Klausel in diesem Beispiel ist identisch mit der Anweisung in dem Beispiel Hierarchie mit Aggregat verwendet.
   SHAPE           (SHAPE   {select customers.*, orders.orderid, orders.orderdate                     from customers inner join orders                     on customers.customerid = orders.customerid}            APPEND  ({select od.orderid,                             od.unitprice * od.quantity as ExtendedPrice                      from [order details] as od} AS rsDetails                    RELATE orderid TO orderid),                    SUM(rsDetails.ExtendedPrice) AS OrderTotal) AS rsOrders   COMPUTE  rsOrders,            SUM(rsOrders.OrderTotal) AS CustTotal,            ANY(rsOrders.contactname) AS Contact   BY       customerid				
Das ergibt:
   rsOrders        |        +----Customers.*             orderid             orderdate             rsDetails                  |                  +----orderid                       ExtendedPrice             OrderTotal   CustomerTotal   Contact   customerid				

Mehrere Gruppen:

   SHAPE          (SHAPE  {select customers.*,                          od.unitprice * od.quantity as ExtendedPrice                   from (customers inner join orders                   on customers.customerid = orders.customerid) inner join                   [order details] as od on orders.orderid = od.orderid}                          AS rsDetail           COMPUTE ANY(rsDetail.contactname) AS Contact,                   ANY(rsDetail.region) AS Region,                   SUM(rsDetail.ExtendedPrice) AS CustTotal,                   rsDetail           BY customerid) AS rsCustSummary   COMPUTE rsCustSummary   BY      Region				
Das ergibt:
   rsCustSummary        |        +-----Contact              Region              CustTotal              rsDetail                   |                   +----Customers.*                        ExtendedPrice              customerid   Region				

Gesamtsumme:

   SHAPE          (SHAPE  {select customers.*,                          od.unitprice * od.quantity as ExtendedPrice                   from (customers inner join orders                   on customers.customerid = orders.customerid) inner join                   [order details] as od on orders.orderid = od.orderid}                          AS rsDetail           COMPUTE ANY(rsDetail.contactname) AS Contact,                   SUM(rsDetail.ExtendedPrice) AS CustTotal,                   rsDetail           BY customerid) AS rsCustSummary   COMPUTE SUM(rsCustSummary.CustTotal) As GrandTotal,           rsCustSummary				
Beachten Sie die fehlende BY -Klausel in der äußeren Summary. Wird die Gesamtsumme definiert, da das übergeordnete Rowset einen Einzelsatz mit der Gesamtsumme und einen Zeiger auf das untergeordnete Recordset enthält.
   GrandTotal   rsCustSummary        |        +-----Contact              CustTotal              rsDetail                  |                  +----Customers.*                       ExtendedPrice              customerid				

Komplexe Hierarchie:

Dieses Beispiel zeigt eine Hierarchie, die ein übergeordnetes Rowset, zwei untergeordnete Rowsets, die, die davon parametrisiert wird, und ein Gruppendetail.
   SHAPE {select customers.* from customers} AS rsDetail   COMPUTE rsDetail,           ANY(rsDetail.companyname) AS Company,           ({select * from orders where customerid = ?}                   RELATE customerid TO PARAMETER 0) AS rsOrders,           COUNT(rsOrders.orderid) AS OrderCount   BY customerid				
Das ergibt:
rsDetail        |        +----Customers.*   Company   rsOrders        |        +----Orders.*   OrderCount   customerid				

Gruppierte übergeordnete gruppierten untergeordneten beziehen:

   SHAPE          (SHAPE  {select * from customers}           APPEND ((SHAPE {select orders.*, year(orderdate) as OrderYear,                                  month(orderdate) as OrderMonth                           from orders} AS rsOrders                    COMPUTE rsOrders                    BY customerid, OrderYear, OrderMonth)                    RELATE customerid TO customerid) AS rsOrdByMonth )           AS rsCustomers   COMPUTE rsCustomers   BY      region				
Das ergibt:
   rsCustomers        |        +-----customers.*              rsOrdByMonth                 |                 +-----rsOrders                            |                            +---- Orders.*                       customerid                       OrderYear                       OrderMonth   region				

SHAPE-Klausel-formale Grammatik

  <shape-command>      ::=  SHAPE <table-exp> [AS <alias>]                            [<shape_action>]  <shape-action>       ::=  APPEND <aliased-field-list>                            | COMPUTE <aliased-field-list>                              [BY <field-list>]                            | BY <field-list>  <table-exp>          ::=  {<native-sql-statement>}                            | ( <shape-command> )   <aliased-field-list> ::=  <aliased-field> [, <aliased-field...]   <aliased-field>      ::=  <field-exp> [AS <alias>]   <field-exp>          ::=  ( <relation-exp> ) | <calculated-exp>   <relation_exp>       ::=   <table-exp> [AS <alias>] RELATE                             <relation-cond-list>   <relation-cond-list> ::=   <relation-cond> [, <relation-cond>...]   <relation-cond>      ::=   <field-name> TO <child-ref>   <child-ref>          ::=   <field-name> | PARAMETER <param-ref>   <param-ref>          ::=   <name> | <number>   <field-list>         ::=   <field-name [, <filed-name>]   <calculated-exp>     ::=   SUM (<qualified-field-name>)                             | AVG (<qualified-field-name>)                             | MIN (<qualified-field-name>)                             | MAX (<qualified-field-name>)                             | COUNT (<alias>)                             | SDEV (<qualified-field-name>)                             | ANY (<qualified-field-name>)                             | CALC (<expression>)   <qualified-field-name>::=  <alias>.<field-name> | <field-name>   <alias>               ::=  <quoted-name>   <field-name>          ::=  <quoted-name>   <quoted-name>         ::=  "<string>" | '<string>' | <name>   <name>                ::=  alpha [ alpha | digit | _ | # ...]   <number>              ::=  digit [digit...]   <string>              ::=  unicode-char [unicode-char...]   <expression>          ::=  an expression recognized by the Jet                             Expression service whose operands are                             other non-CALC columns in the same row.				

VBA-SHAPE Testprogramm

Programmcode von VBA aktiviert Typ im SHAPE -Befehl und Feldhierarchie anzeigen oder die Position der Syntaxfehler anzugeben.

Warnung: verwendet der CODE IN diesem Artikel auf Ihr eigenes Risiko. Microsoft stellt diese "wie besehen" ohne Gewährleistung jeglicher Art, gleich ob ausdrücklich oder konkludent, einschließlich, aber nicht beschränkt auf konkludente Garantien der Handelsüblichkeit und/oder Eignung für einen bestimmten Zweck.
  1. Fügen Sie im ODBC-Administrator des Bedienfelds DSNfor OLE_DB_NWIND_JET auf TheNorthwind (oder NWIND) Datenbank namens Microsoft Access 97 ODBC-Treiber hinzu.
  2. Erstellen Sie ein neues Projekt. Fügen Sie zwei Textfeldern (Text1 und Text2) und eine Schaltfläche (Command1).
  3. Stellen Sie beide Textfelder groß genug ist, mehrere Linesof Text und die folgenden Eigenschaften:
          Multiline: True                (Visual Basic only)      Scrollbars: Vertical      Font: Courier New 10 Point					
  4. Im Menü Projekt wählen Sie Referenzen und einen Verweis auf Microsoft ActiveX Data ObjectsLibrary.
  5. Fügen Sie den folgenden Code hinzu:
       Private Sub Command1_Click()   Dim cn As ADODB.Connection, rs As ADODB.Recordset     Me!Text2.Text = ""     Set cn = New ADODB.Connection     Set rs = New ADODB.Recordset     cn.Provider = "MSDataShape"     cn.Open "dsn=OLE_DB_NWIND_JET"     On Error Resume Next     rs.Open Me!Text1.Text, cn, adOpenStatic, adLockReadOnly, adCmdText     If Err Then MsgBox Error     ListChapteredFields rs, 0     rs.Close     cn.Close     Set rs = Nothing     Set cn = Nothing   End Sub   Private Sub LogText(ByVal sLine As String)     If Me!Text2.Text = "" Then       Me!Text2.Text = sLine     Else       Me!Text2.Text = Me!Text2.Text & vbCrLf & sLine     End If   End Sub   Private Sub ListChapteredFields(ByVal rs As ADODB.Recordset, _                                      ByVal Level As Long)   Dim I As Long     For I = 0 To rs.Fields.Count - 1       LogText Space$(Level * 3) & rs(I).Name       If rs(I).Type = adChapter Then         ListChapteredFields rs(I).Value, Level + 1       End If     Next I   End Sub					
  6. Führen Sie das Projekt aus. Text1 Geben Sie SHAPE -Befehl ein, klicken Sie auf die Befehlsschaltfläche Hierarchyappears in Text2.
Hinweis: der folgende Text enthält ein Beispiel der SHAPE-Provider mit Microsoft Jet OLEDB-Provider:
  cn.Provider = "MSDataShape"  cn.Open "Data Provider=Microsoft.Jet.OLEDB.4.0"				
Hinweis: die Access 97 ODBC-Treiber oder Provider JOLT Feld-oder Tabelle Fehler, erhalten Sie folgende Meldung:
Zu wenige Parameter. Erwartete n.
Andere Anbieter möglicherweise eine andere Meldung erzeugen.
Informationsquellen
ADO 2.0 hierarchische Cursor-Spezifikation

Weitere Informationen über SHAPE APPEND -Syntax und hierarchische Recordsets durchlaufen finden Sie im folgenden Artikel der Microsoft Knowledge Base:
185425 ADO-Recordset über SHAPE APPEND über C / VBA-Java

Warnung: Dieser Artikel wurde automatisch übersetzt.

Eigenschaften

Artikelnummer: 189657 – Letzte Überarbeitung: 10/04/2015 11:16:00 – Revision: 2.0

Microsoft ActiveX Data Objects 2.7

  • kbdatabase kbhowto kbprovider kbmt KB189657 KbMtde
Feedback