Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale.
Traduzione
Originale

Utilizzo dello strumento di associazione di query

Uno strumento di associazione di query è un modello di sviluppo sul lato client che offre il livello massimo di flessibilità e riutilizzabilità per la creazione di applicazioni StreamInsight. In questo modello gli adattatori e i modelli di query vengono registrati come oggetti di metadati separati che possono essere associati in ordine in seguito per creare un'istanza di una query. In questo modo, lo sviluppatore dispone di controllo completo sull'applicazione e sull'ambiente di sviluppo utilizzando un'associazione di query esplicita sull'API del modello a oggetti.

I tipici casi di utilizzo per il modello di sviluppo server esplicito includono applicazioni StreamInsight che richiedono quanto segue:

  • Controllo e accesso completi al server StreamInsight.

  • Riutilizzo di query tramite composizione statica o dinamica delle query o riutilizzo di adattatori, tipi di evento e modelli di query definiti da una terza parte.

Il modello dello strumento di associazione di query ha le caratteristiche chiave seguenti:

  • Lo sviluppatore deve creare tutti gli oggetti di metadati in modo esplicito e registrarli tutti nel server StreamInsight.

  • Il modello supporta la creazione e l'utilizzo di più oggetti (modelli di query, query, applicazioni e adattatori). Tutti gli oggetti devono essere registrati in un'applicazione.

    Il modello di query e l'istanza di query devono essere registrati in modo esplicito nel server prima di poter eseguire la query. Gli adattatori di input e di output devono essere registrati in modo esplicito perché il modello di query o la query possano fare riferimento a questi oggetti. Tutti gli oggetti, inoltre, devono essere registrati in un'applicazione. I tipi di evento utilizzati dagli adattatori e i modelli di query vengono registrati in modo implicito.

Nell'esempio seguente viene creato un oggetto server StreamInsight e un oggetto applicazione denominato myApp nel server. Vengono quindi creati e registrati tutti gli oggetti StreamInsight necessari per importare, elaborare ed esportare i flussi di eventi.

Vengono creati innanzitutto l'oggetto server e l'oggetto applicazione.

server = Server.Create(“MyInstance”);
Application myApp = server.CreateApplication("MyApp");

Vengono quindi registrati gli adattatori di input e di output nell'applicazione.

InputAdapter inputAdapter = myApp.CreateInputAdapter<MyInputAdapterFactory>("DataSource", "Description of the input adapter");
OutputAdapter outputAdapter = myApp.CreateOutputAdapter<MyOutputAdapterFactory>("Output", " Description of the output adapter ");

Viene specificato il modello di query su un flusso non associato. L'unico parametro necessario per creare un flusso non associato è un nome di flusso, che sarà necessario in un secondo momento per l'associazione dell'adattatore.

var inputstream = CepStream<MyDataType>.Create("filterInput");

var filtered = from e in inputstream
               where e.Value > 95
               select e;

QueryTemplate filterQT = myApp.CreateQueryTemplate("filterLogic", filtered);
  • L'ultima chiamata registra il modello di query nell'applicazione. A questo punto, il modello di query registrato può essere riutilizzato in più associazioni e, pertanto, è possibile crearne un'istanza in più query, ciascuna delle quali associata ad adattatori di input e di output potenzialmente diversi. Tali associazioni per i modelli di query registrati vengono definite tramite l'oggetto QueryBinder:

QueryBinder queryBinder = new QueryBinder(filterQT);

queryBinder.BindProducer<MyDataType>("filterInput",
                                      inputAdapter,
                                      new InputAdapterConfig { someFlag = true },
                                      EventShape.Point);

queryBinder.AddConsumer("filterOutput",
                         outputAdapter,
                         new OutputAdapterConfig { someString = "foo" },
                         EventShape.Point,
                         StreamEventOrder.FullyOrdered);

Query query = myApp.CreateQuery("filterQuery", "My Filter Query", queryBinder);

Il metodo BindProducer() associa un oggetto adattatore di input (che deve essere registrato nell'applicazione) a un flusso con il nome specificato, qui "filterInput". In questo modo, è possibile distinguere tra più punti di ingresso di un modello di query. Insieme all'adattatore di input, sono necessari i parametri specifici dell'associazione, ovvero la configurazione dell'adattatore e la forma evento desiderata.

Il metodo AddConsumer() associa un oggetto adattatore di output (che deve essere registrato nell'applicazione) al singolo flusso in uscita del modello di query. Il nome del flusso di output specificato, qui "validated", può essere utilizzato per identificare il flusso per scopi di diagnostica. Come per l'adattatore di input, vengono forniti i parametri di associazione specifici per l'adattatore di output.

L'oggetto query viene creato in base allo strumento di associazione di query, a un identificatore di query e a una descrizione testuale. L'ultimo passaggio consiste nell'avviare la query.

query.Start();

Query con più flussi di input

Nell'esempio seguente viene illustrato come creare un modello di query che utilizza più flussi di input. Un modello di query può includere più punti di ingresso, ciascuno inserito da un'origine dati diversa, ad esempio quando è necessario unire due flussi. L'associazione corretta dei flussi viene eseguita tramite la specifica del nome di flusso, come illustrato nell'esempio seguente.

CepStream<SensorReading> sensorStream = CepStream<SensorReading>.Create("sensorInput");
CepStream<LocationData> locationStream = CepStream<LocationData>.Create("locationInput");

// Define query template in LINQ on top of sensorStream and locationStream
// ...
// Create query binder like in the previous example
// ...

InputAdapter inputAdapter = application.CreateInputAdapter<TextFileInputFactory>("CSVInput", "Reading tuples from a CSV file");

qb.BindProducer<SensorReading>("sensorInput", inputAdapter, sensorInputConf, EventShape.Interval);
qb.BindProducer<LocationData>("locationInput", inputAdapter, locationInputConf, EventShape.Edge);

Modifica di un'applicazione esistente

Si noti che è possibile utilizzare il modello dello strumento di associazione di query con gli oggetti modello di query e adattatore senza averli necessariamente creati nella stessa applicazione. Nell'esempio seguente si presuppone una connessione a un server esistente e vengono recuperate le entità di metadati esistenti tramite l'API del modello a oggetti di StreamInsight anziché crearne di nuove.

Application myApp = server.Applications["app1"];
QueryTemplate myQueryTemplate = myApp.QueryTemplates["qt1"];
InputAdapter myInputAdapter = myApp.InputAdapters["sensorAdapter5"];

Utilizzo di un archivio di metadati persistente

Quando si crea un server StreamInsight, il tipo di archivio di metadati da utilizzare è un parametro facoltativo del metodo Server.Create(). Per impostazione predefinita, i metadati vengono archiviati in memoria. Facoltativamente, i metadati possono anche essere salvati in modo persistente su disco tramite un database di SQL Server Compact 3.5. Nell'esempio seguente viene illustrato come specificare un database di SQL Server Compact 3.5 come archivio di metadati.

SqlCeMetadataProviderConfiguration metadataConfiguration = new SqlCeMetadataProviderConfiguration();
metadataConfiguration.DataSource = "SIMetadata.sdf";
metadataConfiguration.CreateDataSourceIfMissing = streamHostConfig.CreateDataSourceIfMissing;

server = Server.Create(”MyInstance”, metadataConfiguration);
Application myApp = server.CreateApplication("MyApp");

Si noti che se si specifica un database di metadati esistente durante la creazione del server, tutti i metadati verranno letti dal file specificato. Le entità di metadati possono essere recuperate tramite l'API del modello a oggetti di StreamInsight.

using (Server server = Server.Create("MyInstance"))
{
try
{
    Application myApp = server.CreateApplication("MyApp");
    InputAdapter inputAdapter = myApp.CreateInputAdapter<MyInputAdapterFactory>("DataSource", "Description of the input adapter");
    OutputAdapter outputAdapter = myApp.CreateOutputAdapter<MyOutputAdapterFactory>("Output", " Description of the output adapter ");

    var inputstream = CepStream<MyDataType>.Create("filterInput");

    var filtered = from e in inputstream
                   where e.Value > 95
                   select e;

    QueryTemplate filterQT = myApp.CreateQueryTemplate("filterLogic", "Description of the query template", filtered);
    QueryBinder queryBinder = new QueryBinder(filterQT);

    queryBinder.BindProducer<MyDataType>("filterInput",
                                         inputAdapter,
                                         new InputAdapterConfig { someFlag = true },
                                         EventShape.Point);

    queryBinder.AddConsumer("filterOutput",
                                                 outputAdapter,
                                                 new OutputAdapterConfig { someString = "foo" },
                                                 EventShape.Point,
                                                 StreamEventOrder.FullyOrdered);

    Query query = myApp.CreateQuery("filterQuery", "My Filter Query", queryBinder);

    query.Start();
    Console.ReadLine();
    query.Stop();
}
catch (Exception e)
{
    Console.WriteLine(e.ToString());
}
}

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft