Java Database Connectivity Data Mediator Service für Datenzugriff verwenden

Die folgenden Schritte veranschaulichen, wie Sie die Metadaten für einen JDBC-DMS (Java Database Connectivity, Data Mediator Service) erstellen und den DMS-DataGraph instanziieren.

Vorgehensweise

  1. Metadatenfactory erstellen Diese Factory kann zum Erstellen von Metadaten, Tabellen, Spalten, Filtern, Filterargumenten, Datenbankvorgaben, Schlüsseln, OrderBy-Objekten und Beziehungen verwendet werden.
    MetadataFactory factory = MetadataFactory.eINSTANCE;
    Metadata metadata = factory.createMetadata();
  2. Tabelle für die Metadaten erstellen Hierfür gibt es zwei Möglichkeiten. Entweder erstellt die Metadatenfactory die Tabelle, die dann automatisch zu den bereits erstellten Metadaten hinzugefügt wird, oder die Metadaten erstellen eine neue Tabelle, und fügen diese hinzu. In diesem Beispiel wird für das Erstellen der Tabelle CUSTOMER die zweite Option verwendet, da diese weniger Schritte umfasst.
    Table custTable = metadata.addTable("CUSTOMER");
  3. Stammtabelle für die Metadaten festlegen Hierfür gibt es ebenfalls zwei Möglichkeiten. Die Tabelle kann sich selbst als Stammtabelle deklarieren oder die Metadaten legen ihre eigene Stammtabelle fest. Schreiben Sie für die erste Option den folgenden Code:
    custTable.beRoot();
    Falls Sie die zweite Option nutzen möchten, schreiben Sie den folgenden Code:
    metadata.setRootTable(custTable)
  4. Tabellenspalten konfigurieren Die Beispieltabelle hat den Namen CUSTOMER. Die einzelnen Spalten werden nach Typ erstellt. In den Metadaten können nur Spaltentypen verwendet werden, die vom verwendeten JDBC-Treiber unterstützt werden. Falls Sie Fragen zu den vom verwendeten JDBC-Treiber unterstützten Typen haben, informieren Sie sich in der Dokumentation zum JDBC-Treiber.
    Column custID = custTable.addIntegerColumn("CUSTID");
    custID.setNullable(false);
    Dieses Beispiel erstellt für diese Spalte ein Spaltenobjekt, jedoch nicht für die übrigen Spalten, weil diese Spalte den Primärschlüssel (der Metadaten) enthält und nach dem Hinzufügen der übrigen Spalten verwendet wird, um den Primärschlüssel der Tabelle festzulegen. Ein Primärschlüssel muss ungleich null sein. Mit custID.setNullable(false) wird deshalb ein Wert gleich null verhindert. Die übrigen Spalten werden wie folgt hinzugefügt:
    custTable.addStringColumn("CUSTFIRSTNAME");
    custTable.addStringColumn("CUSTLASTNAME");
    custTable.addStringColumn("CUSTSTREETADDRESS");
    custTable.addStringColumn("CUSTCITY");
    custTable.addStringColumn("CUSTSTATE");
    custTable.addStringColumn("CUSTZIPCODE");
    custTable.addIntegerColumn("CUSTAREACODE");
    custTable.addStringColumn("CUSTPHONENUMBER");
    
    custTable.setPrimaryKey(custID);
  5. Weitere Tabellen nach Bedarf erstellen Für dieses Beispiel wird die Tabelle Orders erstellt. Jeder Bestellung (Order) ist ein Kunde (Customer) zugeordnet.
    Table orderTable = metadata.addTable("ORDER");
    
    Column orderNumber = orderTable.addIntegerColumn("ORDERNUMBER");
    orderNumber.setNullable(false);
    
    orderTable.addDateColumn("ORDERDATE");
    orderTable.addDateColumn("SHIPDATE");
    Column custFKColumn = orderTable.addIntegerColumn("CUSTOMERID");
    
    orderTable.setPrimaryKey(orderNumber);
  6. Fremdschlüssel für Tabellen, die Beziehungen erfordern, erstellen In diesem Beispiel haben Bestellungen einen Fremdschlüssel, der auf den Kunden zeigt, der die Bestellung aufgegeben hat. Um eine Beziehung zwischen den beiden Tabellen herstellen zu können, müssen Sie zunächst einen Fremdschlüssel für die Tabelle Orders erstellen.
    Key custFK = factory.createKey();
    custFK.getColumns().add(custFKColumn);
    
    orderTable.getForeignKeys().add(custFK);
    Für die Beziehung werden zwei Schlüssel verwendet, der übergeordnete und der untergeordnete Schlüssel. Da kein spezieller Name angegeben ist, wird als Name für diese Beziehung die Standardverknüpfung CUSTOMER_ORDER verwendet.
    metadata.addRelationship(custTable.getPrimaryKey(), custFK);
    Die Standardbeziehung umfasst alle Kunden, die Bestellungen aufgegeben haben. Falls Sie alle Kunden abrufen möchten, auch die, die keine Bestellung aufgegeben haben, benötigen Sie außerdem die folgende Zeile:
    metadata.getRelationship("CUSTOMER_ORDER") 
                                  .setExclusive(false); 
    Die beiden Tabellen stehen jetzt in Beziehung zueinander. Sie können nun einen Filter zur Tabelle Customer hinzufügen, um Kunden mit bestimmten Kenndaten zu finden.
  7. Erforderliche Filter angeben In diesem Beispiel werden für die Tabelle Customer Filter festgelegt, mit denen alle Kunden gefunden werden, die Bestellungen aufgegeben haben und die einen bestimmten Status und einen bestimmten Nachnamen haben.
    Filter filter = factory.createFilter();
    filter.setPredicate("CUSTOMER.CUSTSTATE = ? AND CUSTOMER.CUSTLASTNAME = ?");
    
    FilterArgument arg1 = factory.createFilterArgument();
    arg1.setName("CUSTSTATE");
    arg1.setType(Column.STRING);
    filter.getFilterArguments().add(arg1);
    
    FilterArgument arg2 = factory.createFilterArgument();
    arg2.setName("CUSTLASTNAME");
    arg2.setType(Column.STRING);
    filter.getFilterArguments().add(arg2);
    
    custTable.setFilter(filter);
  8. Erforderliche OrderBy-Objekte hinzufügen Definieren Sie das OrderBy-Objekt in diesem Beispiel so, dass es die Kunden nach dem Vornamen sortiert.
    Column firstName = ((TableImpl)custTable).getColumn("CUSTFIRSTNAME");
    OrderBy orderBy = factory.createOrderBy();
    orderBy.setColumn(firstName);
    orderBy.setAscending(true);
    metadata.getOrderBys().add(orderBy);
    Damit sind die Metadaten für diesen JDBC DMS erstellt.
  9. Verbindung zur Datenbank erstellen. Dieses Beispiel zeigt nicht, wie die Verbindung zur Datenbank hergestellt wird. Es wird davon ausgegangen, dass der SDO-Client hierfür die Methode connect() aufruft.
  10. Instanziieren und initialisieren Sie das JDBC-DMS-Objekt (dataGraph). Der SDO-Client führt diese Aktionen aus. Für dieses Beispiel gilt Folgendes:
    ConnectionWrapperFactory factory = ConnectionWrapperFactory.soleInstance;
    connectionWrapper = factory.createConnectionWrapper(connect());
    JDBCMediatorFactory mFactory = JDBCMediatorFactory.soleInstance;
    JDBCMediator mediator = mFactory.createMediator(metadata, connectionWrapper);
    DataObject parameters = mediator.getParameterDataObject();
    parameters.setString("CUSTSTATE", "NY");
    parameters.setString('CUSTLASTNAME', 'Smith');
    DataObject graph = mediator.getGraph(parameters);
    Nachdem Sie den dataGraph erstellt haben, können Sie die Informationen nach Bedarf bearbeiten. Das folgende Beispiel veranschaulicht die grundlegende Bearbeitung von Daten in einem DataGraph-Objekt.
    Beispiel: Daten in einem DataGraph-Objekt bearbeiten

    Im Folgenden werden einige typische Datenänderungen anhand des in der Task "Java Database Connectivity Data Mediator Service für Datenzugriff verwenden" erstellten einfachen Datengraphen erläutert:

    Rufen Sie zuerst die Liste der Kunden ab, rufen Sie dann für jeden Kunden die einzelnen Aufträge ab, und geben Sie anschließend den Vornamen des Kunden und das Auftragsdatum aus. (In diesem Beispiel wird vorausgesetzt, dass Sie bereits wissen, dass der Nachname des Kunden Smith ist.)
    List customersList = graph.getList("CUSTOMER");
    Iterator i = customersList.iterator();
    while (i.hasNext()) {
                         DataObject customer = (DataObject)i.next();
    List ordersList = customer.getList("CUSTOMER_ORDER");
    Iterator j = ordersList.iterator();
    while (j.hasNext())
    {
    DataObject order = (DataObject)j.next();
    System.out.print( customer.get("CUSTFIRSTNAME") + " ");
    System.out.println( order.get("ORDERDATE"));
     }
    }
    Ändern Sie jetzt alle Kunden, die den Vornamen "Will" haben, in "Matt".
    i = customersList.iterator();
    while (i.hasNext()) {
                         DataObject customer = (DataObject)i.next();
     if (customer.get("CUSTFIRSTNAME").equals("Will"))
     {
      customer.set("CUSTFIRSTNAME", "Matt");
     }
    }
    Löschen Sie den ersten ersten Kundeneintrag.
    ((DataObject) customersList.get(0)).delete();
    Fügen Sie dem Graphen ein neues DataObject hinzu:
    DataObject newCust = graph.createDataObject("CUSTOMER");
    newCust.setInt("CUSTID", 12345);
    newCust.set("CUSTFIRSTNAME", "Will");
    newCust.set("CUSTLASTNAME", "Smith");
    newCust.set("CUSTSTREETADDRESS", "123 Main St.");
    newCust.set("CUSTCITY", "New York");
    newCust.set("CUSTSTATE", "NY");
    newCust.set("CUSTZIPCODE", "12345");
    newCust.setInt("CUSTAREACODE", 555);
    newCust.set("CUSTPHONENUMBER", "555-5555");
    
    graph.getList("CUSTOMER").add(newCust);
    Übergeben Sie die Änderungen.
    mediator.applyChanges(graph);
  11. Übergeben Sie die geänderten Informationen an den DMS, um die Datenbank zu aktualisieren.

Symbol, das den Typ des Artikels anzeigt. Taskartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tdat_jdbcmeduse
Dateiname:tdat_jdbcmeduse.html