XQuery API dla Javy

XQJ
Deweloperzy	Proces społeczności Java
Wersja stabilna	1.0 / 24 czerwca 2009
Typ	API dostępu do danych
Strona internetowa	JSR 225: API XQuery dla Javy

Ogólna architektura sposobu, w jaki sterownik XQJ jest używany do komunikacji z bazą danych XML z aplikacji Java.

XQuery API for Java ( XQJ ) odnosi się do wspólnego API Java dla specyfikacji W3C XQuery 1.0.

XQJ API umożliwia programistom Javy wykonywanie XQuery na źródle danych XML (np. bazie danych XML ), jednocześnie zmniejszając lub eliminując blokadę dostawcy .

XQJ API zapewnia programistom Javy interfejs do XQuery Data Model. Jego konstrukcja jest podobna do interfejsu API JDBC , który ma charakter klient/serwer i jako taki dobrze nadaje się do opartych na serwerze baz danych XML , a gorzej do procesorów XQuery po stronie klienta, chociaż część „ połączenia ” jest bardzo niewielką częścią całe API. Użytkownicy interfejsu API XQJ mogą wiązać wartości Java z wyrażeniami XQuery , zapobiegając atakom polegającym na wstrzykiwaniu kodu . Również wiele XQuery wyrażenia mogą być wykonywane jako część niepodzielnej transakcji .

Historia i realizacja

Interfejs API XQuery dla Javy został opracowany w Java Community Process jako JSR 225 . Miał kilku dużych sponsorów technologicznych, takich jak Oracle , IBM , BEA Systems , Software AG , Intel , Nokia i DataDirect .

Wersja 1.0 interfejsu API XQuery dla specyfikacji Java została wydana 24 czerwca 2009 r. wraz z JavaDocs , implementacją referencyjną i zestawem TCK (Technology Compatibility Kit), z którym dostawcy implementacji muszą być zgodni.

Klasy XQJ są zawarte w pakiecie Java javax.xml.xquery

Nie ma (widocznej) czynności tworzenia wersji XQJ, która zapewnia obsługę XQuery 3.0 lub 3.1, na przykład poprzez dostarczanie powiązań Java dla dodatków do modelu danych, takich jak funkcje, tablice lub mapy.

Funkcjonalność

XQJ umożliwia istnienie wielu implementacji i używanie ich przez tę samą aplikację.

Połączenia XQJ obsługują tworzenie i wykonywanie wyrażeń XQuery . Wyrażenia mogą być aktualizowane i mogą obejmować wyszukiwanie pełnotekstowe. XQJ reprezentuje XQuery przy użyciu jednej z następujących klas:

XQExpression – wyrażenie jest każdorazowo wysyłane do procesora XQuery.
XQPreparedExpression – wyrażenie jest buforowane, a ścieżka wykonania jest z góry określona, co pozwala na jego wielokrotne wykonanie w efektywny sposób.

XQuery zwracają sekwencję wynikową elementów XDM, które w XQJ są reprezentowane przez interfejs XQResultSequence . Programista może użyć XQResultSequence , aby przejść przez poszczególne elementy XDM w sekwencji wyników. Każdy element w sekwencji ma powiązane informacje o typie XDM, takie jak jego typ węzła, np. element() , document-node() lub atomowy typ XDM, taki jak xs:string , xs:integer lub xs:dateTime . Informacje o typie XDM w XQJ można pobrać za pomocą XQItemType interfejs.

Atomowe elementy XQuery można łatwo rzutować na prymitywy Java za pomocą metod XQItemAccessor , takich jak getByte() i getFloat() . Również XQuery mogą być serializowane do DOM Node , SAX ContentHandler , StAX XMLStreamReader oraz ogólnych klas IO Reader i InputStream .

Przykłady

Podstawowy przykład

Poniższy przykład ilustruje tworzenie połączenia z bazą danych XML , przesyłanie wyrażenia XQuery , a następnie przetwarzanie wyników w języku Java . Po przetworzeniu wszystkich wyników połączenie jest zamykane, aby zwolnić wszystkie powiązane z nim zasoby.


    

    

   
    // Utwórz nowe połączenie z bazą danych XML  XQConnection  conn  =  vendorDataSource  .  getConnection  (  "myUser"  ,  "myPassword"  );  Wyrażenie  XQExpression  =  conn  .  utwórzWyrażenie  ();  // Tworzenie wielokrotnego użytku obiektu XQuery Expression  XQResultSequence  result  =  expr  .  executeQuery  (  "dla $n w fn:collection('catalog')//item "  + 
   


  
    
      



 "zwróć fn:dane($n/nazwa)"  );  // wykonaj wyrażenie XQuery  // Przetwórz sekwencję wyników iteracyjnie  while  (  result  .  next  ())  {  // Wydrukuj bieżący element w sekwencji  System  .  na  zewnątrz  println  (  "Nazwa produktu: "  +  wynik  .  getItemAsString  (  null  ));  }  // Zwolnij wszystkie zasoby utworzone przez połączenie  conn  .  zamknij  ();

Wiązanie wartości ze zmienną zewnętrzną

Poniższy przykład ilustruje sposób powiązania wartości Java ze zmienną zewnętrzną w wyrażeniu XQuery . Załóżmy, że połączenie conn już istnieje:

   


    
             
             
            


  Wyrażenie  XQExpression  =  conn  .  utwórzWyrażenie  ();  // Wyrażenie XQuery do wykonania  String  es  =  "deklaruj zmienną $x jako xs:integer external;"  +  " for $n in fn:collection('catalog')//item"  +  " gdzie $n/cena <= $x"  +  " return fn:data($n/name)"  ;  // Powiąż wartość (21) ze zmienną zewnętrzną za pomocą QName x  expr  .  bindInt  (  nowy  QName  (   


   


  
    
 "x"  ),  21  ,  null  );  // Wykonaj wyrażenie XQuery  XQResultSequence  result  =  expr  .  wykonaj zapytanie  (  es  );  // Przetwarzaj wynik (sekwencję) iteracyjnie  while  (  result  .  next  ())  {  // Przetwarzaj wynik ...  }

Domyślne mapowanie typu danych

Mapowanie między typami danych Java i XQuery jest w dużej mierze elastyczne, jednak specyfikacja XQJ 1.0 ma domyślne reguły mapowania mapujące typy danych, gdy nie są one określone przez użytkownika. Te reguły mapowania są bardzo podobne do reguł mapowania, które można znaleźć w JAXB .

Poniższa tabela ilustruje domyślne reguły mapowania podczas wiązania wartości Java ze zmiennymi zewnętrznymi w wyrażeniach XQuery .

Domyślne reguły konwersji podczas mapowania typów danych Java na typy danych XQuery
Typ danych Javy	Domyślne typy danych XQuery
`logiczna`	`xs: wartość logiczna`
`bajt`	`xs: bajt`
`bajt[]`	`xs:hexDwójkowy`
`podwójnie`	`xs: podwójne`
`platforma`	`xs: liczba zmiennoprzecinkowa`
`int`	`xs:int`
`długi`	`xs: długi`
`krótki`	`xs: krótki`
`logiczne`	`xs: wartość logiczna`
`Bajt`	`xs: bajt`
`Platforma`	`xs: liczba zmiennoprzecinkowa`
`Podwójnie`	`xs: podwójne`
`Liczba całkowita`	`xs:int`
`Długi`	`xs: długi`
`Krótki`	`xs: krótki`
`Strunowy`	`xs: ciąg`
`Duży dziesiętny`	`xs: dziesiętny`
`Duża liczba całkowita`	`xs: liczba całkowita`
`Czas trwania`	`xs:dayTimeDuration` , jeśli stan obiektu `Duration to` `xs:dayTimeDuration`
	`xs:yearMonthDuration` , jeśli stan obiektu `Duration to` `xs:yearMonthDuration`
	`xs:duration` , jeśli stan obiektu `Duration to` `xs:duration`
`XMLGregorianCalendar`	`xs:date` , jeśli stan obiektu `XMLGregorianCalendar to` `xs:date`
	`xs:dateTime` , jeśli stan obiektu `XMLGregorianCalendar` `to xs:dateTime`
	`xs:gDay,` jeśli stan obiektu `XMLGregorianCalendar to` `xs:gDay`
	`xs:gMonth` , jeśli stan obiektu `XMLGregorianCalendar to` `xs:gMonth`
	`xs:gMonthDay` , jeśli stan obiektu `XMLGregorianCalendar to` `xs:gMonthDay`
	`xs: gYear` , jeśli stan obiektu `XMLGregorianCalendar to` `xs:gYear`
	`xs:gYearMonth,` jeśli Stan obiektu `XMLGregorianCalendar to` `xs:gYearMonth`
	`xs:time` , jeśli stan obiektu `XMLGregorianCalendar to` `xs:time`
`QNazwa`	`xs:QNazwa`
`Dokument`	`węzeł dokumentu (element (*, xs: bez typu))`
`fragment dokumentu`	`węzeł dokumentu (element (*, xs: bez typu))`
`Element`	`element(*, xs: bez typu)`
`atr`	`atrybut(*, xs:nieopisany atomowy)`
`Komentarz`	`komentarz()`
`Instrukcja przetwarzania`	`instrukcja przetwarzania ()`
`Tekst`	`tekst()`

Znane implementacje

Natywne bazy danych XML

Poniżej znajduje się lista rodzimych baz danych XML , o których wiadomo, że mają implementacje XQuery API for Java.

Relacyjne bazy danych

DataDirect zapewnia adaptery XQJ dla relacyjnych baz danych , tłumacząc kod XQuery na język SQL w locie, a następnie konwertując zestawy wyników SQL do formatu odpowiedniego do dalszego przetwarzania przez XQJ. Poniżej przedstawiono kilka znanych implementacji.

Implementacje inne niż bazy danych

Poniżej znajduje się lista procesorów XQuery niezwiązanych z bazami danych, które zapewniają interfejs API XQuery dla interfejsu Java (zwykle umożliwiający zapytania do dokumentów przeanalizowanych z XML w magazynie plików i przechowywanych w pamięci jako DOM lub podobne drzewa).

Saksoński procesor XSLT i XQuery
Zorba
Zapytanie MX
Procesor Oracle XQuery

Licencja

Specyfikacja zawiera dwie odrębne licencje: „licencję na specyfikację” oraz „licencję na wdrożenie referencyjne”.

Licencja specyfikacji umożliwia bezpłatne kopiowanie specyfikacji pod warunkiem zachowania informacji o prawach autorskich; udziela również licencji na tworzenie i dystrybucję implementacji specyfikacji, pod warunkiem, że w pełni implementuje ona całą specyfikację, nie modyfikuje ani nie rozszerza żadnych interfejsów oraz przechodzi testy kompatybilności.

Przepis ten wzbudził pewne kontrowersje. Po pierwsze, nie jest powszechnie akceptowane, że wdrożenie opublikowanej specyfikacji wymaga licencji (to znaczy, że prawo autorskie zabraniałoby tego w przypadku braku licencji). Po drugie, licencja nie spełnia kryteriów pozwalających na zakwalifikowanie jej jako open source (patrz Definicja Open Source ), ze względu na zakaz dokonywania rozszerzeń i modyfikacji. Doprowadziło to niektórych entuzjastów open source do kwestionowania tego, czy implementacje XQJ można kiedykolwiek uznać za prawdziwie open source.

Licencja na referencyjną implementację jest dość konwencjonalną licencją open source w stylu BSD.

Linki zewnętrzne