Ridimensionare esecuzione e test locali di U-SQL con l'SDK U-SQL di Azure Data LakeScale U-SQL local run and test with Azure Data Lake U-SQL SDK

Durante lo sviluppo di script U-SQL, è comune eseguire e testare a livello locale gli script U-SQL prima di inviarli al cloud.When developing U-SQL script, it is common to run and test U-SQL script locally before submit it to cloud. Per questo scenario, Azure Data Lake offre un pacchetto NuGet, denominato SDK U-SQL di Azure Data Lake, tramite cui è possibile ridimensionare facilmente l'esecuzione e il test locali di U-SQL.Azure Data Lake provides a Nuget package called Azure Data Lake U-SQL SDK for this scenario, through which you can easily scale U-SQL local run and test. È inoltre possibile integrare questo test di U-SQL con il sistema CI (Continuous Integration, integrazione continua) per automatizzare la compilazione e il test.It is also possible to integrate this U-SQL test with CI (Continuous Integration) system to automate the compile and test.

Per capire come eseguire in locale manualmente ed eseguire il debug di uno script U-SQL con gli strumenti della GUI, è possibile usare gli Strumenti Azure Data Lake per Visual Studio.If you care about how to manually local run and debug U-SQL script with GUI tooling, then you can use Azure Data Lake Tools for Visual Studio for that. Altre informazioni sono disponibili qui.You can learn more from here.

Installare l'SDK U-SQL di Azure Data LakeInstall Azure Data Lake U-SQL SDK

È possibile ottenere l'SDK U-SQL di Azure Data Lake qui su Nuget.org. Prima di usarlo, è necessario assicurarsi di avere le dipendenze indicate di seguito.You can get the Azure Data Lake U-SQL SDK here on Nuget.org. And before using it, you need to make sure you have dependencies as follows.

DipendenzeDependencies

L'SDK U-SQL di Data Lake richiede le dipendenze seguenti:The Data Lake U-SQL SDK requires the following dependencies:

  • Microsoft .NET Framework 4.6 o versione successiva.Microsoft .NET Framework 4.6 or newer.
  • Microsoft Visual C++ 14 e Windows SDK 10.0.10240.0 o versione successiva (CppSDK in questo articolo).Microsoft Visual C++ 14 and Windows SDK 10.0.10240.0 or newer (which is called CppSDK in this article). Esistono due modi per ottenerlo:There are two ways to get CppSDK:

    • Installare Visual Studio Community Edition.Install Visual Studio Community Edition. Sarà presente la cartella \Windows Kits\10 sotto la cartella Programmi, ad esempio C:\Programmi (x86)\Windows Kits\10.You'll have a \Windows Kits\10 folder under the Program Files folder--for example, C:\Program Files (x86)\Windows Kits\10. Sarà disponibile anche la versione Windows 10 SDK in \Windows Kits\10\Lib.You'll also find the Windows 10 SDK version under \Windows Kits\10\Lib. Se queste cartelle non sono presenti, reinstallare Visual Studio e selezionare Windows 10 SDK durante l'installazione.If you don’t see these folders, reinstall Visual Studio and be sure to select the Windows 10 SDK during the installation. Se è installato con Visual Studio, verrà trovato automaticamente dal compilatore locale U-SQL.If you have this installed with Visual Studio, the U-SQL local compiler will find it automatically.

      Windows 10 SDK ad esecuzione locale degli strumenti di Data Lake per Visual Studio

    • Installare Strumenti Data Lake per Visual Studio.Install Data Lake Tools for Visual Studio. I file di Windows SDK e Visual C++ preassemblati sono disponibili in C:\Programmi (x86)\Microsoft Visual Studio 14.0\Common7\IDE\Extensions\Microsoft\ADL Tools\X.X.XXXX.X\CppSDK.You can find the prepackaged Visual C++ and Windows SDK files at C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\Extensions\Microsoft\ADL Tools\X.X.XXXX.X\CppSDK. In questo caso il compilazione locale di U-SQL non è in grado di trovare le dipendenze automaticamente.In this case, the U-SQL local compiler cannot find the dependencies automatically. È necessario specificare il relativo percorso CppSDK.You need to specify the CppSDK path for it. È possibile copiare i file in un altro percorso o usarli così come sono.You can either copy the files to another location or use it as is.

Comprendere i concetti di baseUnderstand basic concepts

Radice dei datiData root

La cartella data-root è un "archivio locale" per l'account di calcolo locale,The data-root folder is a "local store" for the local compute account. equivalente all'account di Azure Data Lake Store di un account Data Lake Analytics.It's equivalent to the Azure Data Lake Store account of a Data Lake Analytics account. Il passaggio a un'altra cartella data-root è identico al passaggio a un account archivio differente.Switching to a different data-root folder is just like switching to a different store account. Se si vuole accedere a dati comunemente condivisi con cartelle data-root diverse, è necessario usare percorsi assoluti negli script.If you want to access commonly shared data with different data-root folders, you must use absolute paths in your scripts. In alternativa è possibile creare collegamenti simbolici del file system (ad esempio mklink in un sistema NTFS) nella cartella data-root che puntino ai dati condivisi.Or, create file system symbolic links (for example, mklink on NTFS) under the data-root folder to point to the shared data.

La cartella data-root viene usata per:The data-root folder is used to:

  • Archiviare i metadati locali, inclusi database, tabelle, funzioni con valori di tabella e assembly.Store local metadata, including databases, tables, table-valued functions (TVFs), and assemblies.
  • Cercare i percorsi di input e output che sono definiti come percorsi relativi in U-SQL.Look up the input and output paths that are defined as relative paths in U-SQL. L'uso di percorsi relativi semplifica la distribuzione dei progetti di U-SQL in Azure.Using relative paths makes it easier to deploy your U-SQL projects to Azure.

Percorso dei file in U-SQLFile path in U-SQL

Negli script U-SQL è possibile usare sia un percorso relativo sia un percorso assoluto locale.You can use both a relative path and a local absolute path in U-SQL scripts. Il percorso relativo è relativo al percorso della cartella data-root specificato.The relative path is relative to the specified data-root folder path. È consigliabile usare "/" come separatore del percorso per rendere gli script compatibili con il lato server.We recommend that you use "/" as the path separator to make your scripts compatible with the server side. Di seguito sono riportati alcuni esempi di percorsi relativi e dei loro percorsi assoluti equivalenti.Here are some examples of relative paths and their equivalent absolute paths. In questi esempi la cartella data-root è C:\LocalRunDataRoot.In these examples, C:\LocalRunDataRoot is the data-root folder.

Percorso relativoRelative path Percorso assolutoAbsolute path
/abc/def/input.csv/abc/def/input.csv C:\LocalRunDataRoot\abc\def\input.csvC:\LocalRunDataRoot\abc\def\input.csv
abc/def/input.csvabc/def/input.csv C:\LocalRunDataRoot\abc\def\input.csvC:\LocalRunDataRoot\abc\def\input.csv
D:/abc/def/input.csvD:/abc/def/input.csv D:\abc\def\input.csvD:\abc\def\input.csv

Directory di lavoroWorking directory

Quando si esegue lo script U-SQL localmente, durante la compilazione viene creata una directory di lavoro nella directory di lavoro corrente.When running the U-SQL script locally, a working directory is created during compilation under current running directory. Oltre agli output di compilazione, nella directory di lavoro verrà creata una copia shadow dei file di runtime necessari per l'esecuzione locale.In addition to the compilation outputs, the needed runtime files for local execution will be shadow copied to this working directory. La cartella radice della directory di lavoro è denominata "ScopeWorkDir" e i file nella directory di lavoro sono i seguenti:The working directory root folder is called "ScopeWorkDir" and the files under the working directory are as follows:

Directory/FileDirectory/file Directory/FileDirectory/file Directory/FileDirectory/file DefinizioneDefinition DescrizioneDescription
C6A101DDCB470506C6A101DDCB470506 Stringa di hash della versione di runtimeHash string of runtime version Copia shadow dei file di runtime necessari per l'esecuzione localeShadow copy of runtime files needed for local execution
Script_66AE4909AA0ED06CScript_66AE4909AA0ED06C Nome di script + stringa hash del percorso dello scriptScript name + hash string of script path Output di compilazione e registrazione del passaggio di esecuzioneCompilation outputs and execution step logging
_script_.abr_script_.abr Output del compilatoreCompiler output File algebraAlgebra file
_ScopeCodeGen_._ScopeCodeGen_. Output del compilatoreCompiler output Codice gestito generatoGenerated managed code
_ScopeCodeGenEngine_._ScopeCodeGenEngine_. Output del compilatoreCompiler output Codice nativo generatoGenerated native code
referenced assembliesreferenced assemblies Riferimento assemblyAssembly reference File assembly di riferimentoReferenced assembly files
deployed_resourcesdeployed_resources Distribuzione risorseResource deployment File di distribuzione risorseResource deployment files
xxxxxxxx.xxx[1..n]_*.xxxxxxxx.xxx[1..n]_*. Log di esecuzioneExecution log Log dei passaggi di esecuzioneLog of execution steps

Usare l'SDK dalla riga di comandoUse the SDK from the command line

Interfaccia della riga di comando dell'applicazione helperCommand-line interface of the helper application

In SDK directory\build\runtime, LocalRunHelper.exe è l'applicazione helper della riga di comando che offre interfacce alla maggior parte delle funzioni di esecuzione locale di uso comune.Under SDK directory\build\runtime, LocalRunHelper.exe is the command-line helper application that provides interfaces to most of the commonly used local-run functions. Entrambe le opzioni di comandi e argomenti fanno distinzione tra maiuscole e minuscole.Note that both the command and the argument switches are case-sensitive. Per richiamarle:To invoke it:

LocalRunHelper.exe <command> <Required-Command-Arguments> [Optional-Command-Arguments]

Eseguire LocalRunHelper.exe senza argomenti o con l'interruttore Guida per mostrare le informazioni della Guida:Run LocalRunHelper.exe without arguments or with the help switch to show the help information:

> LocalRunHelper.exe help

    Command 'help' :  Show usage information
    Command 'compile' :  Compile the script
    Required Arguments :
        -Script param
                Script File Path
    Optional Arguments :
        -Shallow [default value 'False']
                Shallow compile

Nelle informazioni di aiuto:In the help information:

  • Comando indica il nome del comando.Command gives the command’s name.
  • Argomento richiesto elenca gli argomenti che devono essere forniti.Required Argument lists arguments that must be supplied.
  • Argomento facoltativo elenca gli argomenti facoltativi con i valori predefiniti.Optional Argument lists arguments that are optional, with default values. Gli argomenti Boolean facoltativi non hanno parametri e la loro comparsa ha un significato negativo per il loro valore predefinito.Optional Boolean arguments don’t have parameters, and their appearances mean negative to their default value.

Valore restituito e registrazioneReturn value and logging

L'applicazione helper restituisce 0 in caso di successo e -1 in caso di errore.The helper application returns 0 for success and -1 for failure. Per impostazione predefinita, l'helper invia tutti i messaggi alla console corrente.By default, the helper sends all messages to the current console. Tuttavia, la maggior parte dei comandi supporta l'argomento facoltativo-MessageOut path_to_log_file che reindirizza gli output in un file di log.However, most of the commands support the -MessageOut path_to_log_file optional argument that redirects the outputs to a log file.

Configurazione della variabile di ambienteEnvironment variable configuring

Per l'esecuzione locale di U-SQL è necessaria una radice di dati specificata come account di archiviazione locale, oltre a un percorso CppSDK specificato per le dipendenze.U-SQL local run needs a specified data root as local storage account, as well as a specified CppSDK path for dependencies. È possibile impostare l'argomento nella riga di comando o impostare la variabile dell'ambiente.You can both set the argument in command-line or set environment variable for them.

  • Impostare la variabile di ambiente SCOPE_CPP_SDK.Set the SCOPE_CPP_SDK environment variable.

    Se si ottiene Microsoft Visual C++ e Windows SDK dall'installazione di Strumenti di Data Lake per Visual Studio, verificare di avere la cartella seguente:If you get Microsoft Visual C++ and the Windows SDK by installing Data Lake Tools for Visual Studio, verify that you have the following folder:

      C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\Extensions\Microsoft\Microsoft Azure Data Lake Tools for Visual Studio 2015\X.X.XXXX.X\CppSDK
    

    Definire una nuova variabile di ambiente denominata SCOPE_CPP_SDK che punti a questa directory.Define a new environment variable called SCOPE_CPP_SDK to point to this directory. In alternativa copiare la cartella in un'altra posizione e specificare SCOPE_CPP_SDK.Or copy the folder to the other location and specify SCOPE_CPP_SDK as that.

    Oltre a impostare la variabile di ambiente, è possibile specificare l'argomento -CppSDK quando si usa la riga di comando.In addition to setting the environment variable, you can specify the -CppSDK argument when you're using the command line. Questo argomento sovrascrive la variabile di ambiente CppSDK predefinita.This argument overwrites your default CppSDK environment variable.

  • Impostare la variabile di ambiente LOCALRUN_DATAROOT.Set the LOCALRUN_DATAROOT environment variable.

    Definire una nuova variabile di ambiente denominata LOCALRUN_DATAROOT che punta alla cartella data-root.Define a new environment variable called LOCALRUN_DATAROOT that points to the data root.

    Oltre a impostare la variabile di ambiente, è possibile specificare l'argomento -DataRoot con il percorso di data-root quando si usa la riga di comando.In addition to setting the environment variable, you can specify the -DataRoot argument with the data-root path when you're using a command line. Questo argomento sovrascrive la variabile di ambiente data-root predefinita.This argument overwrites your default data-root environment variable. È necessario aggiungere questo argomento a ogni riga di comando eseguita, così da poter sovrascrivere la variabile di ambiente data-root predefinita per tutte le operazioni.You need to add this argument to every command line you're running so that you can overwrite the default data-root environment variable for all operations.

Esempi di uso della riga di comando SDKSDK command line usage samples

Compila ed eseguiCompile and run

Il comando run viene usato per compilare lo script ed eseguire i risultati compilati.The run command is used to compile the script and then execute compiled results. Gli argomenti della riga di comando sono una combinazione degli argomenti di compile ed execute.Its command-line arguments are a combination of those from compile and execute.

LocalRunHelper run -Script path_to_usql_script.usql [optional_arguments]

Di seguito sono indicati gli argomenti facoltativi per run:The following are optional arguments for run:

ArgomentoArgument Valore predefinitoDefault value DescrizioneDescription
-CodeBehind-CodeBehind FalseFalse Lo script ha code-behind con estensione csThe script has .cs code behind
-CppSDK-CppSDK Directory CppSDKCppSDK Directory
-DataRoot-DataRoot Variabile di ambiente DataRootDataRoot environment variable DataRoot per l'esecuzione locale, impostazione predefinita su variabile di ambiente 'LOCALRUN_DATAROOT'DataRoot for local run, default to 'LOCALRUN_DATAROOT' environment variable
-MessageOut-MessageOut Messaggi dump sulla console a un fileDump messages on console to a file
-Parallel-Parallel 11 Esegue il piano con il parallelismo specificatoRun the plan with the specified parallelism
-References-References Elenco di percorsi agli assembly di riferimento aggiuntivi o a file di dati code-behind, separati da ";"List of paths to extra reference assemblies or data files of code behind, separated by ';'
-UdoRedirect-UdoRedirect FalseFalse Genera la configurazione di reindirizzamento di assembly UdoGenerate Udo assembly redirect config
-UseDatabase-UseDatabase mastermaster Database da usare per la registrazione di assembly temporanei code-behindDatabase to use for code behind temporary assembly registration
-Verbose-Verbose FalseFalse Mostrare gli output dettagliati dal runtimeShow detailed outputs from runtime
-WorkDir-WorkDir Directory correnteCurrent Directory Directory per l'uso del compilatore e gli outputDirectory for compiler usage and outputs
-RunScopeCEP-RunScopeCEP 00 Modalità ScopeCEP da usareScopeCEP mode to use
-ScopeCEPTempPath-ScopeCEPTempPath temptemp Percorso temporaneo da usare per lo streaming di datiTemp path to use for streaming data
-OptFlags-OptFlags Elenco delimitato da virgole con i flag di ottimizzazioneComma-separated list of optimizer flags

Ad esempio:Here's an example:

LocalRunHelper run -Script d:\test\test1.usql -WorkDir d:\test\bin -CodeBehind -References "d:\asm\ref1.dll;d:\asm\ref2.dll" -UseDatabase testDB –Parallel 5 -Verbose

Oltre a combinare i comandi compile ed execute, è possibile compilare ed eseguire separatamente i file eseguibili compilati.Besides combining compile and execute, you can compile and execute the compiled executables separately.

Compilare uno script U-SQLCompile a U-SQL script

Il comando compile viene usato per compilare uno script di U-SQL in file eseguibili.The compile command is used to compile a U-SQL script to executables.

LocalRunHelper compile -Script path_to_usql_script.usql [optional_arguments]

Di seguito sono indicati gli argomenti facoltativi per il comando compile:The following are optional arguments for compile:

ArgomentoArgument DescrizioneDescription
-CodeBehind [valore predefinito 'False']-CodeBehind [default value 'False'] Lo script ha code-behind con estensione csThe script has .cs code behind
-CppSDK [valore predefinito '']-CppSDK [default value ''] Directory CppSDKCppSDK Directory
-DataRoot [valore predefinito 'DataRoot environment variable']-DataRoot [default value 'DataRoot environment variable'] DataRoot per l'esecuzione locale, impostazione predefinita su variabile di ambiente 'LOCALRUN_DATAROOT'DataRoot for local run, default to 'LOCALRUN_DATAROOT' environment variable
-MessageOut [valore predefinito '']-MessageOut [default value ''] Messaggi dump sulla console a un fileDump messages on console to a file
-References [valore predefinito '']-References [default value ''] Elenco di percorsi agli assembly di riferimento aggiuntivi o a file di dati code-behind, separati da ";"List of paths to extra reference assemblies or data files of code behind, separated by ';'
-Shallow [valore predefinito 'False']-Shallow [default value 'False'] Compilazione superficialeShallow compile
-UdoRedirect [valore predefinito 'False']-UdoRedirect [default value 'False'] Genera la configurazione di reindirizzamento di assembly UdoGenerate Udo assembly redirect config
-UseDatabase [valore predefinito 'master']-UseDatabase [default value 'master'] Database da usare per la registrazione di assembly temporanei code-behindDatabase to use for code behind temporary assembly registration
-WorkDir [valore predefinito 'Current Directory']-WorkDir [default value 'Current Directory'] Directory per l'uso del compilatore e gli outputDirectory for compiler usage and outputs
-RunScopeCEP [valore predefinito '0']-RunScopeCEP [default value '0'] Modalità ScopeCEP da usareScopeCEP mode to use
-ScopeCEPTempPath [valore predefinito 'temp']-ScopeCEPTempPath [default value 'temp'] Percorso temporaneo da usare per lo streaming di datiTemp path to use for streaming data
-OptFlags [valore predefinito '']-OptFlags [default value ''] Elenco delimitato da virgole con i flag di ottimizzazioneComma-separated list of optimizer flags

Di seguito sono riportati alcuni esempi d'uso.Here are some usage examples.

Compilare uno script U-SQL:Compile a U-SQL script:

LocalRunHelper compile -Script d:\test\test1.usql

Compilare uno script U-SQL e impostare la cartella data-root.Compile a U-SQL script and set the data-root folder. Si noti la variabile di ambiente impostata verrà sovrascritta.Note that this will overwrite the set environment variable.

LocalRunHelper compile -Script d:\test\test1.usql –DataRoot c:\DataRoot

Compilare uno script U-SQL e impostare la directory di lavoro, un assembly di riferimento e un database:Compile a U-SQL script and set a working directory, reference assembly, and database:

LocalRunHelper compile -Script d:\test\test1.usql -WorkDir d:\test\bin -References "d:\asm\ref1.dll;d:\asm\ref2.dll" -UseDatabase testDB

Eseguire i risultati compilatiExecute compiled results

Il comando execute viene usato per eseguire i risultati compilati.The execute command is used to execute compiled results.

LocalRunHelper execute -Algebra path_to_compiled_algebra_file [optional_arguments]

Di seguito sono indicati gli argomenti facoltativi per il comando execute:The following are optional arguments for execute:

ArgomentoArgument DescrizioneDescription
-DataRoot [valore predefinito '']-DataRoot [default value ''] Radice dei dati per l'esecuzione dei metadati.Data root for metadata execution. Il valore predefinito è la variabile di ambiente LOCALRUN_DATAROOT.It defaults to the LOCALRUN_DATAROOT environment variable.
-MessageOut [valore predefinito '']-MessageOut [default value ''] Esecuzione del dump dei messaggi della console in un file.Dump messages on the console to a file.
-Parallel [valore predefinito '1']-Parallel [default value '1'] Indica di eseguire i passaggi di esecuzione locale generati con il livello di parallelismo specificato.Indicator to run the generated local-run steps with the specified parallelism level.
-Verbose [valore predefinito 'False']-Verbose [default value 'False'] Indica di visualizzare output dettagliati dal runtime.Indicator to show detailed outputs from runtime.

Ecco un esempio d'uso:Here's a usage example:

LocalRunHelper execute -Algebra d:\test\workdir\C6A101DDCB470506\Script_66AE4909AA0ED06C\__script__.abr –DataRoot c:\DataRoot –Parallel 5

Uso dell'SDK con interfacce di programmazioneUse the SDK with programming interfaces

Le interfacce di programmazione si trovano tutte in LocalRunHelper.exe.The programming interfaces are all located in the LocalRunHelper.exe. È possibile usarle per integrare le funzionalità dell'SDK U-SQL e il framework di test di C# per scalare il test locale dello script U-SQL.You can use them to integrate the functionality of the U-SQL SDK and the C# test framework to scale your U-SQL script local test. In questo articolo verrà usato il progetto di unit test C# standard per mostrare come usare queste interfacce per testare lo script U-SQL.In this article, I will use the standard C# unit test project to show how to use these interfaces to test your U-SQL script.

Passaggio 1: Creare configurazione e progetto per unit test C#Step 1: Create C# unit test project and configuration

  • Creare un progetto per unit test C# tramite File > Nuovo > Progetto > Visual C# > Test > Progetto unit test.Create a C# unit test project through File > New > Project > Visual C# > Test > Unit Test Project.
  • Aggiungere LocalRunHelper.exe come riferimento per il progetto.Add LocalRunHelper.exe as a reference for the project. LocalRunHelper.exe si trova in \build\runtime\LocalRunHelper.exe nel pacchetto NuGet.The LocalRunHelper.exe is located at \build\runtime\LocalRunHelper.exe in Nuget package.

    Riferimento aggiunta dell'SDK U-SQL di Azure Data Lake

  • L'SDK U-SQL supporta solo l'ambiente x64, quindi è necessario assicurarsi di impostare la piattaforma di destinazione della compilazione come x64.U-SQL SDK only support x64 environment, make sure to set build platform target as x64. È possibile farlo da Proprietà progetto > Build > Piattaforma di destinazione.You can set that through Project Property > Build > Platform target.

    Progetto configurazione x64 SDK U-SQL di Azure Data Lake

  • Assicurarsi di impostare l'ambiente di testing come x64.Make sure to set your test environment as x64. In Visual Studio è possibile impostarlo tramite Test > Impostazioni test > Architettura processore predefinita > x64.In Visual Studio, you can set it through Test > Test Settings > Default Processor Architecture > x64.

    Ambiente di testing configurazione x64 SDK U-SQL di Azure Data Lake

  • Assicurarsi di copiare tutti i file di dipendenza in NugetPackage\build\runtime\ nella directory di lavoro del progetto che generalmente si trova in ProjectFolder\bin\x64\Debug.Make sure to copy all dependency files under NugetPackage\build\runtime\ to project working directory which is usually under ProjectFolder\bin\x64\Debug.

Passaggio 2: Creare test case per lo script U-SQLStep 2: Create U-SQL script test case

Di seguito è riportato il codice di esempio per il test dello script U-SQL.Below is the sample code for U-SQL script test. Per i test, è necessario preparare script, file di input e file di output previsti.For testing, you need to prepare scripts, input files and expected output files.

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System.Text;
using System.Security.Cryptography;
using Microsoft.Analytics.LocalRun;

namespace UnitTestProject1
{
    [TestClass]
    public class USQLUnitTest
    {
        [TestMethod]
        public void TestUSQLScript()
        {
            //Specify the local run message output path
            StreamWriter MessageOutput = new StreamWriter("../../../log.txt");

            LocalRunHelper localrun = new LocalRunHelper(MessageOutput);

            //Configure the DateRoot path, Script Path and CPPSDK path
            localrun.DataRoot = "../../../";
            localrun.ScriptPath = "../../../Script/Script.usql";
            localrun.CppSdkDir = "../../../CppSDK";

            //Run U-SQL script
            localrun.DoRun();

            //Script output 
            string Result = Path.Combine(localrun.DataRoot, "Output/result.csv");

            //Expected script output
            string ExpectedResult = "../../../ExpectedOutput/result.csv";

            Test.Helpers.FileAssert.AreEqual(Result, ExpectedResult);

            //Don't forget to close MessageOutput to get logs into file
            MessageOutput.Close();
        }
    }
}

namespace Test.Helpers
{
    public static class FileAssert
    {
        static string GetFileHash(string filename)
        {
            Assert.IsTrue(File.Exists(filename));

            using (var hash = new SHA1Managed())
            {
                var clearBytes = File.ReadAllBytes(filename);
                var hashedBytes = hash.ComputeHash(clearBytes);
                return ConvertBytesToHex(hashedBytes);
            }
        }

        static string ConvertBytesToHex(byte[] bytes)
        {
            var sb = new StringBuilder();

            for (var i = 0; i < bytes.Length; i++)
            {
                sb.Append(bytes[i].ToString("x"));
            }
            return sb.ToString();
        }

        public static void AreEqual(string filename1, string filename2)
        {
            string hash1 = GetFileHash(filename1);
            string hash2 = GetFileHash(filename2);

            Assert.AreEqual(hash1, hash2);
        }
    }
}

Interfacce di programmazione in LocalRunHelper.exeProgramming interfaces in LocalRunHelper.exe

LocalRunHelper.exe offre le interfacce di programmazione per la compilazione e l'esecuzione locale di U-SQL e così via. Le interfacce sono elencate come di seguito.LocalRunHelper.exe provides the programming interfaces for U-SQL local compile, run, etc. The interfaces are listed as follows.

CostruttoreConstructor

public LocalRunHelper([System.IO.TextWriter messageOutput = null])public LocalRunHelper([System.IO.TextWriter messageOutput = null])

.Parameter TipoType DescrizioneDescription
messageOutputmessageOutput System.IO.TextWriterSystem.IO.TextWriter per i messaggi di output, impostato su null per usare Consolefor output messages, set to null to use Console

ProprietàProperties

ProprietàProperty TipoType DescrizioneDescription
AlgebraPathAlgebraPath stringstring Il percorso al file algebra (il file algebra è uno dei risultati della compilazione)The path to algebra file (algebra file is one of the compilation results)
CodeBehindReferencesCodeBehindReferences stringstring Se lo script contiene riferimenti code-behind aggiuntivi, specificare i percorsi separati da ';'If the script has additional code behind references, specify the paths separated with ';'
CppSdkDirCppSdkDir stringstring Directory CppSDKCppSDK directory
CurrentDirCurrentDir stringstring La directory correnteCurrent directory
DataRootDataRoot stringstring Il percorso della radice dei datiData root path
DebuggerMailPathDebuggerMailPath stringstring Il percorso alla porta di inserimento/espulsione del debuggerThe path to debugger mailslot
GenerateUdoRedirectGenerateUdoRedirect boolbool Se si vuole generare il reindirizzamento di caricamento dell'assembly eseguire l'override della configurazioneIf we want to generate assembly loading redirection override config
HasCodeBehindHasCodeBehind boolbool Indica se lo script ha code-behindIf the script has code behind
InputDirInputDir stringstring La directory per i dati di inputDirectory for input data
MessagePathMessagePath stringstring Il percorso del file dump del messaggioMessage dump file path
OutputDirOutputDir stringstring La directory per i dati di outputDirectory for output data
ParallelismoParallelism intint Il parallelismo per eseguire l'algebraParallelism to run the algebra
ParentPidParentPid intint Il PID dell'entità principale in cui il servizio esegue il monitoraggio per uscire, impostato su 0 o su un numero negativo se va ignoratoPID of the parent on which the service monitors to exit, set to 0 or negative to ignore
ResultPathResultPath stringstring Il percorso del file dump del risultatoResult dump file path
RuntimeDirRuntimeDir stringstring La directory di runtimeRuntime directory
ScriptPathScriptPath stringstring Indica dove trovare lo scriptWhere to find the script
ShallowShallow boolbool Indica se la compilazione è superficiale o noShallow compile or not
TempDirTempDir stringstring Directory TempTemp directory
UseDataBaseUseDataBase stringstring Specifica il database da usare per la registrazione di assembly temporanei code-behind; master per impostazione predefinitaSpecify the database to use for code behind temporary assembly registration, master by default
WorkDirWorkDir stringstring La directory di lavoro preferitaPreferred working directory

MetodoMethod

MetodoMethod DescrizioneDescription ReturnReturn .Parameter
public bool DoCompile()public bool DoCompile() Consente di compilare lo script U-SQLCompile the U-SQL script Se l'esito è positivo, restituisce il valore trueTrue on success
public bool DoExec()public bool DoExec() Esegue il risultato compilatoExecute the compiled result Se l'esito è positivo, restituisce il valore trueTrue on success
public bool DoRun()public bool DoRun() Esegue lo script U-SQL (compile + execute)Run the U-SQL script (Compile + Execute) Se l'esito è positivo, restituisce il valore trueTrue on success
public bool IsValidRuntimeDir(string path)public bool IsValidRuntimeDir(string path) Controlla se il percorso specificato è un percorso di runtime validoCheck if the given path is valid runtime path Se è valido, restituisce il valore trueTrue for valid Il percorso della directory di runtimeThe path of runtime directory

Domande frequenti sui problemi comuniFAQ about common issue

Errore 1:Error 1:

E_CSC_SYSTEM_INTERNAL: Internal error!E_CSC_SYSTEM_INTERNAL: Internal error! Could not load file or assembly 'ScopeEngineManaged.dll' or one of its dependencies.Could not load file or assembly 'ScopeEngineManaged.dll' or one of its dependencies. The specified module could not be found. (E_CSC_SYSTEM_INTERNAL: errore interno. Impossibile caricare il file o l'assembly 'ScopeEngineManaged.dll' o una delle sue dipendenze. Impossibile trovare il modulo specificato.)The specified module could not be found.

Verificare quanto segue:Please check the following:

  • Assicurarsi di avere un ambiente x64.Make sure you have x64 environment. La piattaforma di destinazione di compilazione e l'ambiente di testing devono essere x64; fare riferimento alla sezione Passaggio 1: Creare configurazione e progetto per unit test C# sopra.The build target platform and the test environment should be x64, refer to Step 1: Create C# unit test project and configuration above.
  • Assicurarsi di aver copiato nella directory di lavoro tutti i file di dipendenza presenti in NugetPackage\build\runtime.Make sure you have copied all dependency files under NugetPackage\build\runtime\ to project working directory.

Passaggi successiviNext steps