Linguaggio d'interrogazione di XAM

Così come la fornitura dei mezzi fornitore-indipendenti di generazione, richiamando, modificando e cancellando XSets, la specifica di SNIA XAM v1.0 inoltre definisce un linguaggio d'interrogazione (XAM QL), basato su un sottoinsieme della lingua di SQL, dato che della selezione e di richiamo del XUIDs di XSets basato sui test di verifica soddisfare-definiti.

L'insieme delle parole riservate per questo linguaggio d'interrogazione è abbastanza piccolo: selezioni, dove e, o, non, come, esiste, legare, passivo, typeof, lunghezza, data, ALLINEARE, FALSI, prima che, dopo, contenga e dentro. Dal disegno, le domande di XAM assomigliano ad una dichiarazione prescelta di SQL. Il linguaggio d'interrogazione è senza distinzione fra maiuscole e minuscole ed usa la serie di caratteri di ASCII.

Qui è un esempio di una domanda semplice di XAM:

select ".xset.xuid" where "com.example.name" = ’Tuckers Plantation'

La versione 1.0 della specifica di XAM definisce due livelli del sostegno di linguaggio d'interrogazione, il Livello 1 cioè del Livello 1 e del Livello 2. definisce le domande sulle proprietà e gli attributi di campo in XSets ed è obbligatorio. Tutto il valore di una proprietà di XSet che è accessibile ad un programma di applicazione via la biblioteca di XAM può essere interrogato. Il Livello 2 estende il Livello 1 fino le domande di sostegno su XStreams ed è facoltativo. Entrambi i livelli di domanda sono raggiunti attraverso un singolo, tipo definito di lavoro che tutti i fornitori di XAM devono sostenere. Poiché nessun fornitore che sono informato di ha domande del Livello realmente d'applicazione 2, il resto dei fuochi di questo alberino sulle domande del Livello 1.

Una dichiarazione di domanda di XAM consiste di una clausola prescelta obbligatoria seguita da un facoltativo dove clausola. Per XAM v1.0 l'unica clausola prescelta valida è `prescelto .xset.xuid'. Ciò specifica che l'applicazione sta chiedendo una lista dei valori di XUID. Per esempio

select ".xset.xuid "

restituirà una lista di ogni XSet che è leggibile ai tempi della domanda.

Dove la clausola è usata per specificare un sottoinsieme di XSets da abbinare. Per le domande del Livello 1 si limita ai confronti fra le proprietà di XSet ed i valori e/o attributi di campo letterali ed i valori letterali.

select ".xset.xuid" where ".xam.time.xuid" > date(’2009-02-01T00:00:00.0’)

restituirà la lista di tutto il Xsets che sono stati generati sopra o dopo il 1° febbraio 2009.

Le seguenti esposizioni della tabella che sistemano ed i tipi letterali possono essere confrontati bene.

Le sequenze di fuga di sostegno sono le seguenti. Qualunque altra sequenza di fuga genererà un errore non fatale.

select ".xset.xuid" where "com.example.string-property" = ’This is a string literal’

Per utilizzare una singola citazione in una stringa, custodicala con una sbarra rovesciata

select ".xset.xuid" where "com.example.claimed.ownership" = ’Tucker\’s’

Tutti i casi dei nomi di campo in una stringa di domanda di XAM devono essere citati con le doppie citazioni. Se un nome di campo contiene i caratteri di doppia citazione, ogni carattere di doppia citazione deve essere fuoriuscito usando una sbarra rovesciata. Per esempio, il nome di campo per la proprietà xam_boolean com.example. „ qstring„ dovrebbe essere rappresentato in una domanda As

select ".xam.xuid" where "com.example.\"qstring\"" = TRUE

Se un nome di campo contiene un carattere di sbarra rovesciata, la sbarra rovesciata in se deve essere fuoriuscita con un'altra sbarra rovesciata. Per esempio, il nome di campo per la proprietà xam_double com.example.file \ rapporto dovrebbe essere rappresentato in una domanda As

select ".xam.xuid" where "com.example.file\\ratio" = 100.1

Il linguaggio d'interrogazione accetta il date-time e le costanti letterali XUID-stimate che usando le funzioni del selettore datano rispettivamente () e xuid (). La funzione della data () prende un valore correttamente formato di date-time, specificato poichè una stringa letterale che è costante con la specifica di date-time di XAM.

select ".xset.xuid" where ".xam.time.xuid" = date(’2009-06-01T00:00:00.0’)

La funzione del xuid () prevede un XUID che è sotto forma d'una costante letterale di stringa messa base64. Una costante letterale di stringa impropriamente formata genera un errore non fatale durante l'analisi di domanda.

Gli attributi di campo sono usando raggiunto esiste, typeof, passivo, grippaggio e funzioni del accessor di attributo di campo di lunghezza. Esiste () le analisi funzionali per l'esistenza di un attributo di campo chiamato (proprietà) in un XSet. Valuta PER ALLINEARE se un XSet contiene il campo chiamato valuta al contrario che FALSO.

select ".xset.xuid" where exists("com.example.name")

La funzione del typeof () restituisce il tipo del MIME di campo chiamato in un XSet che è una proprietà stringa-stimata.

select ".xset.xuid" where typeof("com.example.data") = ’text/plain’
select ".xset.xuid" where typeof("com.example.data") like ’text%’

Questa funzione può essere usata ogni volta che un'applicazione potrebbe usare un riferimento del campo ad una proprietà stringa-stimata. Si noti che i confronti con tutto il valore letterale della non-stringa generano un errore non fatale durante l'analisi della domanda.

() La funzione passiva valuta PER ALLINEARE quando un campo in un XSet è contrassegnato come passivo.

select ".xset.xuid" where readonly("com.example.flag")
select ".xset.xuid" where not readonly("com.example.name")

() La funzione obbligatoria valuta PER ALLINEARE quando un campo in un XSet è contrassegnato come legando.

select ".xset.xuid" where binding("com.example.case_id")
select ".xset.xuid" where not binding("com.example.subject")

La funzione di lunghezza () restituisce la lunghezza, in byte, di un campo chiamato.

select ".xset.xuid" where length("com.example.data") > 1024

Una volta usato sulla proprietà sistema i ritorni di questa funzione la lunghezza come definita per gli stypes. Si noti che questa funzione non dovrebbe essere usata per confrontare il numero dei caratteri in una stringa mentre questo confronto dipende dalla codifica del carattere che usando.

Girandosi ora verso gli operatori logici. Preposizioni subordinate all'interno del dove la clausola può essere unita e modificata usando gli operatori logici e, o e non. Questi operatori sono simili alle loro controparti di SQL.

Ed operatore richiede entrambe le preposizioni subordinate di valutare PER ALLINEARE prima compreso un XSet nei risultati. Per esempio

select ".xset.xuid" where typeof("com.example.stream") = ’image/gif’ and length("com.example.stream") > 4096

seleziona soltanto quel XSets che contiene le immagini del GIF di cui il formato è maggior di 4096 byte. O operatore valuta PER ALLINEARE se la una o la altra preposizione subordinata valuta PER ALLINEARE. Per esempio

select ".xset.xuid" where typeof("com.example.stream") = ’image/jpeg’ or typeof("com.example.stream") = ’image/gif’

seleziona soltanto quel XSets che contiene un flusso chiamato del tipo JPEG o GIF di immagine. Non l'operatore nega un'espressione booleana. Per esempio

select ".xset.xuid" where not binding("com.example.property")

seleziona tutto il XSets con la proprietà nonbinding com.example.property.

Come negli operatori sicuri di SQL prenda la precedenza sopra altri operatori nelle domande. La precedenza di operatore di XAM QL è come segue:

select ".xset.xuid" where not "com.example.bool-prop" and  "com.example.int-prop" = 64
select ".xset.xuid" where not ("com.example.bool-prop" and "com.example.int-prop" = 64)

Nel primo esempio, non l'operatore si applica soltanto alla proprietà di com.example.bool-prop. Nel secondo esempio, non l'operatore si applica sia a com.example.bool-prop che a com.example.int-prop = 42.

Ora che abbiamo una conoscenza di in qualche modo con sintassi di XAM QL, la domanda seguente da rispondere a è come diciamo un sistema di memorizzazione di XAM di eseguire una domanda e di restituire i risultati noi. Risulta bene che una domanda è eseguita come un tipo particolare di lavoro di XAM ha denominato un lavoro di domanda. L'input ad un lavoro di domanda è un XSet che dovete generare. Questo XSet deve contenere due articoli - il mand di org.snia.xam.job.com del campo che è regolato sempre a `xam.job.query e ad un mand di XStream xam.job.query.com che è un flusso di testo UTF-8 (tipo testo del MIME del `/normale; charset=utf-8') contenere la stringa reale di espressione di domanda.

Un lavoro di domanda può facoltativamente essere commesso prima di o durante l'esecuzione del lavoro, ma questo commette non è richiesto. La capacità di commettere un lavoro corrente è dipendente di esecuzione e facoltativo. Un'applicazione può determinare se il lavoro commette è sostenuto controllando la proprietà booleana .xsystem.job.com mit.supported di XSystem. L'omissione di commettere un lavoro di domanda prima della chiusura del XSet significa che i risultati del lavoro di domanda non sono immagazzinati con insistenza.

Un lavoro di domanda è eseguito invocando il submitJob. Se l'uno o l'altro dei due articoli richiesti nel lavoro XSet di domanda non è riempito correttamente, il campo standard .xam.job.error di errore di lavoro si aggiunge al lavoro XSet di domanda ed è il valore è regolato ad il uno o il altro org.snia.xam:: not_a_job o org.snia.xam:: il unspecified_command ed il lavoro di domanda è abbandonato. Secondo le indicazioni dell'applicazione di campione qui sotto, la condizione di un lavoro di domanda può essere determinata mediante l'esame del valore di .xam.job.status.

Quando un lavoro di domanda riesce, i risultati sono immagazzinati nel lavoro XSet di domanda sotto forma d'un nuovo XStream chiamato xam.job.query.results. Questo XStream ha un tipo del MIME di applicazione/vnd.snia.xam.query.xuid_list e contiene il XUIDs per l'insieme di XSets derivando dalla valutazione della domanda. Ogni XUID è immagazzinato in una disposizione binaria come componente di un'annotazione da 80 byte. Se un XUID è più breve di 80 byte, l'annotazione è zero riempito a 80 byte.

Un certo numero di altre proprietà concernenti i risultati XStream inoltre sono installate. La proprietà xam.job.query.results.count del xam_int contiene il conteggio corrente delle annotazioni di XUID nei risultati XStream. Questa proprietà è aggiornata mentre i risultati sono inseriti nei risultati XStream durante l'elaborazione di domanda. Un'applicazione può usare questa per fornire informazioni di condizione agli utenti mentre il lavoro di domanda esegue. La proprietà xam_string xam.job.query.level indica il livello di domanda che abbina i risultati. Il relativo valore è org.snia.xam.job.query.level.1 o org.snia.xam.job.query.level.2.

È importante ricordarsi che un lavoro di domanda funziona all'interno dei ruoli e dei permessi assegnati al collegamento. Quello significa che i risultati XStream include soltanto quel XSets che sono visibili ed accessibili ad un'applicazione, almeno da una prospettiva colta, secondo il ruolo nell'ambito di cui il lavoro di domanda è eseguito.

Il lavoro di domanda può fissare i seguenti codici di errore in .xam.job.error:

Si noti che, diverso di un RDBMS tradizionale, non ci è la chiusura di un sistema di memorizzazione di XAM durante l'esecuzione di un lavoro di domanda. Così un risultato di domanda non è una fotografia istantanea istantanea di un sistema di memorizzazione di XAM. Il contenuto di un sistema di memorizzazione di XAM può o può o cambiare mentre un lavoro di domanda è eseguito. La regola generale è che alcun XSet che è stato immagazzinato prima che l'inizio del lavoro di domanda sia incluso nei risultati XStream se risponde ai test di verifica di domanda ed alcun XSet che è stato immagazzinato dopo che il lavoro di domanda ha completato non deve essere incluso nei risultati XStream. XSets che è immagazzinato durante l'esecuzione di lavoro di domanda può o può o essere incluso. Gli stessi test di verifica si applica ai risultati XStream. Può includere XUIDs di XSets che non è più nel sistema di memorizzazione di XAM e nel XUIDs di XSets che più non risponde ai test di verifica di ricerca dovuto un cambiamento nel XSet dopo che il particolare XSet è stato interrogato.

Qui è un'applicazione di Java semplice che interroga un sistema di memorizzazione di XAM per determinarla è livello di sostegno per le domande di XAM.

import org.snia.xam.XAMException;
import org.snia.xam.XAMLibrary;
import org.snia.xam.XSystem;
import org.snia.xam.toolkit.XAMXUID;
import org.snia.xam.util.XAMLibraryFactory;

public class CheckQuerySupport
{
    private static XAMLibrary xamLib;
    private static XSystem xSystem;

    public static void main(String[] args)
    {
        String xri = "snia-xam://centera_vim!XXX.XXXX.XXX.XXX?/home/fpm/xam/xamconnect.pea";

        long exitCode = 0;
        boolean isSupported = false;

        try
        {
            xamLib = XAMLibraryFactory.newXAMLibrary();
            System.out.println("Connecting to XSystem: " + xri + "\n");

            xSystem = xamLib.connect(xri);

            // support job commit?
            isSupported = xSystem.getBoolean(XSystem.XAM_XSYSTEM_JOB_COMMIT_SUPPORTED);
            System.out.println("Support job commit? " + (isSupported ? "Yes" : "No"));

            // support continuance of job?
            isSupported = xSystem.getBoolean(XSystem.XAM_XSYSTEM_JOB_QUERY_CONTINUANCE_SUPPORTED);
            System.out.println("Support job continuance? " + (isSupported ? "Yes" : "No"));

            // support level 1 query?
            isSupported = xSystem.getBoolean(XSystem.XAM_XSYSTEM_JOB_QUERY_LEVEL1_SUPPORTED);
            System.out.println("Support level 1 query? " + (isSupported ? "Yes" : "No"));

            // support level 2 query?
            isSupported = xSystem.getBoolean(XSystem.XAM_XSYSTEM_JOB_QUERY_LEVEL2_SUPPORTED);
            System.out.println("Support level 2 query? " + (isSupported ? "Yes" : "No"));

            xSystem.close();
            System.out.println("\nClosed connection to XSystem");

        } catch (XAMException xe) {
            exitCode = xe.getStatusCode();
            System.err.println("XAM Error occured: " + xe.getMessage());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
            exitCode = 1;
        }

        System.exit((int) exitCode);
    }
}

Qui è l'uscita da questa applicazione una volta collegata ad un sistema di memorizzazione di contabilità elettromagnetica Centera XAM

Connecting to XSystem: snia-xam://centera_vim!XXX.XXX.XXX.XXX?/home/fpm/xam/xamconnect.pea

Support job commit? No
Support job continuance? No
Support level 1 query? Yes
Support level 2 query? No

Closed connection to XSystem

Qui è un'applicazione di Java più lunga che realizza tre il campione XSets e le domande del campione che sono discussi nella parte 10.8 del documento di architettura V1.0 di XAM.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.snia.xam.XAMException;
import org.snia.xam.XAMLibrary;
import org.snia.xam.XSet;
import org.snia.xam.XStream;
import org.snia.xam.XSystem;
import org.snia.xam.XUID;
import org.snia.xam.toolkit.XAMXUID;
import org.snia.xam.util.XAMLibraryFactory;

public class QueryExample
{
    private static XAMLibrary xamLib;
    private static XSystem xSystem;

    private static void CreateXset(int parm1, String parm2, double parm3)
             throws XAMException
    {
        System.out.print("Create XSet 1 ....  ");

        XSet xSet = xSystem.createXSet(XSet.MODE_UNRESTRICTED);
        xSet.createProperty("com.example.rhc", false, true);
        xSet.createProperty("com,example.foo", false, parm1);
        xSet.createProperty("com.example.bar", false, parm2);
        xSet.createProperty("com.example.num", false, parm3);

        XUID xuID = xSet.commit();
        System.out.println("XUID: " + xuID.toString());

        xSet.close();
    }

   private static void CreateXset(int parm1, int parm2, int parm3)
             throws XAMException
    {
        System.out.print("Create XSet 2 ....  ");

        XSet xSet = xSystem.createXSet(XSet.MODE_UNRESTRICTED);
        xSet.createProperty("com.example.rhc", false, true);
        xSet.createProperty("com,example.foo", false, parm1);
        xSet.createProperty("com.example.bar", false, parm2);
        xSet.createProperty("com.example.num", false, parm3);

        XUID xuID = xSet.commit();
        System.out.println("XUID: " + xuID.toString());

        xSet.close();
    }

    private static void CreateXset(int parm1, int parm2)
             throws XAMException
    {
        System.out.print("Create XSet 3 ....  ");

        XSet xSet = xSystem.createXSet(XSet.MODE_UNRESTRICTED);
        xSet.createProperty("com.example.rhc", false, true);
        xSet.createProperty("com,example.foo", false, parm1);
        xSet.createProperty("com.example.num", false, parm2);

        XUID xuID = xSet.commit();
        System.out.println("XUID: " + xuID.toString());

        xSet.close();
    }

    private static void QueryXsystem(String queryString)
            throws XAMException
    {
        boolean finished = false;
        final int XAM_MAX_XUID = 80;
        int resultCount = 0;
        String status;

        System.out.println("Create query XSet. Query string: " + queryString);

        XSet query = xSystem.createXSet(XSet.MODE_UNRESTRICTED);
        query.createProperty(XSet.XAM_JOB_COMMAND, true, XSet.XAM_JOB_QUERY);

        byte[] buffer = queryString.getBytes();
        XStream queryStream = query.createXStream(XSet.XAM_JOB_QUERY_COMMAND, true, XAMLibrary.TEXT_PLAIN_MIME_TYPE);
        queryStream.write(buffer);
        queryStream.close();

        System.out.println("Submit query job ....");
        query.submitJob();

        System.out.println("Wait for query job to finish ....");

        while (!finished)
        {
            // check  status of query job
            status = query.getString(XSet.XAM_JOB_ERRORHEALTH);
            if (status.equals(XSet.XAM_JOB_ERRORHEALTH_ERROR))
            {
                System.out.println("ERROR: Errorhealth - " + query.getString(XSet.XAM_JOB_ERROR));
                query.haltJob();
                System.out.println("ERROR: Job halted");
                break;
            }

            status = query.getString(XSet.XAM_JOB_STATUS);
            resultCount = (int) query.getLong(XSet.XAM_JOB_QUERY_RESULTS_COUNT);

            // uncomment if you want continuous job status
            // System.out.println("Job Status: " + status + "  Result count: " + resultCount);

            // exit loop if job complete
            if (status.equals(XSet.XAM_JOB_STATUS_COMPLETE))
            {
                finished = true;
            }
       }

        System.out.println("Query job completed ....");
        System.out.println("Result set final count is: " + resultCount);

        if (resultCount > 0)
        {
             // open query job result stream
             XStream results = query.openXStream(XSet.XAM_JOB_QUERY_RESULTS, XStream.MODE_READ_ONLY);

             byte rawXUID[] = new byte[XAM_MAX_XUID];
             long bytesRead = 0;

             // output XUIDs in result set
             while( (bytesRead = results.read(rawXUID, XAM_MAX_XUID)) >= 0 )
             {
                 XAMXUID resultXUID = new XAMXUID(rawXUID);
                 System.out.println("XUID: " + resultXUID.toString());
             }

             results.close();
        }

        query.close();
    }

    public static void main(String[] args)
    {
        String xri = "snia-xam://centera_vim!XXX.XXX.XXX.XXX?/home/fpm/xam/xamconnect.pea";
        long exitCode = 0;

        try
        {
            xamLib = XAMLibraryFactory.newXAMLibrary();

            // uncomment next 2 lines if you want extensive XAM Library logging
            // xamLib.setProperty(XAMLibrary.XAM_LOG_VERBOSITY, 1);
            // xamLib.setProperty(XAMLibrary.XAM_LOG_LEVEL, 5);

            System.out.println("Connecting to XSystem " +  xri + "\n");

            xSystem = xamLib.connect(xri);
            xSystem.setProperty(".xsystem.log.verbosity", 1);
            xSystem.setProperty(".xsystem.log.level", 5);

            CreateXset(1, "string", 123.55);
            CreateXset(77, 42, 100);
            CreateXset(6, 200);

            xSystem.close();

            System.out.println("\nClose/reopen XSystem\n");

            xSystem = xamLib.connect(xri);

            // uncomment one or more of the following queries
            // QueryXsystem("select \".xset.xuid\"");
            QueryXsystem("select \".xset.xuid\" where (\"com.example.foo\" > 0) and (\"com.example.foo\" < 50)");
            // QueryXsystem("select \".xset.xuid\" where (\"com.example.bar\" > 0) and (\"com.example.bar\" < 100)");
            // QueryXsystem("select \".xset.xuid\" where exists (\"com.example.bar\")");
            // QueryXsystem("select \".xset.xuid\" where \"com.example.bar\" like '%ing%'");
            // QueryXsystem("select \".xset.xuid\" where \"com.example.num\" >= 124");
            // QueryXsystem("select \".xset.xuid\" where \"com.example.num\" >= 124.6 ");
            // QueryXsystem("select \".xset.xuid\" where (\"com.example.num\" >= 123) and typeof(\"com.example.num\") = 'application/vnd.snia.xam.int'");

            xSystem.close();
            System.out.println("\nClosed connection to XSystem");

        } catch (XAMException xe) {
            exitCode = xe.getStatusCode();
            System.err.println("XAM Error occured: " + xe.getMessage() + "("
                    + exitCode + ")");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
            exitCode = -1;
        }

        System.exit((int) exitCode);
    }
}

Si noti che i risultati XStream prodotto da un lavoro di domanda possono essere consumati da un'applicazione prima che il sistema di memorizzazione di XAM abbia rifinito immagazzinare tutto XUIDs nei risultati XStream se XStream.asyncRead è usato anziché XStream.read.

Penso bene che abbia fornito abbastanza informazioni ed esempi per permettergli di andare gioco con il linguaggio d'interrogazione di XAM da lei. Voi ha bisogno dell'aiuto io sono sicuro che il gruppo dello sviluppatore di XAM sui gruppi del Google sarà più di felice di aiutarlo.

Nella divisione preciserei che poiché i fornitori del sistema di memorizzazione di XAM attualmente sono richiesti soltanto di realizzare il contributo alle domande sopra i meta dati soddisfatti, ritengo sospetto che il contributo alle ricerche in pieno soddisfare-basate reali che usando XAM non può accadere per un po di tempo.