Pipeline Runs - Query By Factory

Referens

Tjänst:: Data Factory

API-version:: 2018-06-01

Frågepipelinen körs i fabriken baserat på villkor för indatafilter.

POST https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns?api-version=2018-06-01

URI-parametrar

Name	I	Obligatorisk	Typ	Description
factoryName	path	True	string	Fabriksnamnet. Reguljärt uttrycksmönster: `^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$`
resourceGroupName	path	True	string	Resursgruppens namn. Reguljärt uttrycksmönster: `^[-\w\._\(\)]+$`
subscriptionId	path	True	string	Prenumerationsidentifieraren.
api-version	query	True	string	API-versionen.

Begärandetext

Name	Obligatorisk	Typ	Description
lastUpdatedAfter	True	string	Tidpunkten då körningshändelsen uppdaterades i FORMATET ISO 8601.
lastUpdatedBefore	True	string	Tidpunkten då körningshändelsen uppdaterades i ISO 8601-format.
continuationToken		string	Fortsättningstoken för att hämta nästa sida med resultat. Null för första sidan.
filters		RunQueryFilter[]	Lista över filter.
orderBy		RunQueryOrderBy[]	Lista över alternativet OrderBy.

Svar

Name	Typ	Description
200 OK	PipelineRunsQueryResponse	OK.
Other Status Codes	CloudError	Ett felsvar som tagits emot från Azure Data Factory-tjänsten.

Säkerhet

azure_auth

Azure Active Directory OAuth2 Flow.

Typ: oauth2
Flow: implicit
Auktoriseringswebbadress: https://login.microsoftonline.com/common/oauth2/authorize

Omfattningar

Name	Description
user_impersonation	personifiera ditt användarkonto

Exempel

PipelineRuns_QueryByFactory

Exempelbegäran

POST https://management.azure.com/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName/queryPipelineRuns?api-version=2018-06-01

{
  "lastUpdatedAfter": "2018-06-16T00:36:44.3345758Z",
  "lastUpdatedBefore": "2018-06-16T00:49:48.3686473Z",
  "filters": [
    {
      "operand": "PipelineName",
      "operator": "Equals",
      "values": [
        "examplePipeline"
      ]
    }
  ]
}


import com.azure.resourcemanager.datafactory.models.RunFilterParameters;
import com.azure.resourcemanager.datafactory.models.RunQueryFilter;
import com.azure.resourcemanager.datafactory.models.RunQueryFilterOperand;
import com.azure.resourcemanager.datafactory.models.RunQueryFilterOperator;
import java.time.OffsetDateTime;
import java.util.Arrays;

/**
 * Samples for PipelineRuns QueryByFactory.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/
     * PipelineRuns_QueryByFactory.json
     */
    /**
     * Sample code: PipelineRuns_QueryByFactory.
     * 
     * @param manager Entry point to DataFactoryManager.
     */
    public static void pipelineRunsQueryByFactory(com.azure.resourcemanager.datafactory.DataFactoryManager manager) {
        manager.pipelineRuns().queryByFactoryWithResponse("exampleResourceGroup", "exampleFactoryName",
            new RunFilterParameters().withLastUpdatedAfter(OffsetDateTime.parse("2018-06-16T00:36:44.3345758Z"))
                .withLastUpdatedBefore(OffsetDateTime.parse("2018-06-16T00:49:48.3686473Z"))
                .withFilters(Arrays.asList(new RunQueryFilter().withOperand(RunQueryFilterOperand.PIPELINE_NAME)
                    .withOperator(RunQueryFilterOperator.EQUALS).withValues(Arrays.asList("examplePipeline")))),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.datafactory import DataFactoryManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-datafactory
# USAGE
    python pipeline_runs_query_by_factory.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = DataFactoryManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="12345678-1234-1234-1234-12345678abc",
    )

    response = client.pipeline_runs.query_by_factory(
        resource_group_name="exampleResourceGroup",
        factory_name="exampleFactoryName",
        filter_parameters={
            "filters": [{"operand": "PipelineName", "operator": "Equals", "values": ["examplePipeline"]}],
            "lastUpdatedAfter": "2018-06-16T00:36:44.3345758Z",
            "lastUpdatedBefore": "2018-06-16T00:49:48.3686473Z",
        },
    )
    print(response)


# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armdatafactory_test

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datafactory/armdatafactory/v9"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ab04533261eff228f28e08900445d0edef3eb70c/specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
func ExamplePipelineRunsClient_QueryByFactory() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatafactory.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPipelineRunsClient().QueryByFactory(ctx, "exampleResourceGroup", "exampleFactoryName", armdatafactory.RunFilterParameters{
		Filters: []*armdatafactory.RunQueryFilter{
			{
				Operand:  to.Ptr(armdatafactory.RunQueryFilterOperandPipelineName),
				Operator: to.Ptr(armdatafactory.RunQueryFilterOperatorEquals),
				Values: []*string{
					to.Ptr("examplePipeline")},
			}},
		LastUpdatedAfter:  to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:36:44.334Z"); return t }()),
		LastUpdatedBefore: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:49:48.368Z"); return t }()),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.PipelineRunsQueryResponse = armdatafactory.PipelineRunsQueryResponse{
	// 	Value: []*armdatafactory.PipelineRun{
	// 		{
	// 			AdditionalProperties: map[string]any{
	// 				"annotations": []any{
	// 				},
	// 				"runDimension": map[string]any{
	// 					"JobId": "79c1cc52-265f-41a5-9553-be65e736fbd3",
	// 				},
	// 			},
	// 			DurationInMs: to.Ptr[int32](28105),
	// 			InvokedBy: &armdatafactory.PipelineRunInvokedBy{
	// 				Name: to.Ptr("Manual"),
	// 				ID: to.Ptr("80a01654a9d34ad18b3fcac5d5d76b67"),
	// 			},
	// 			LastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:38:12.731Z"); return t}()),
	// 			Message: to.Ptr(""),
	// 			Parameters: map[string]*string{
	// 				"OutputBlobNameList": to.Ptr("[\"exampleoutput.csv\"]"),
	// 			},
	// 			PipelineName: to.Ptr("examplePipeline"),
	// 			RunEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:38:12.731Z"); return t}()),
	// 			RunID: to.Ptr("2f7fdb90-5df1-4b8e-ac2f-064cfa58202b"),
	// 			RunStart: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:37:44.625Z"); return t}()),
	// 			Status: to.Ptr("Succeeded"),
	// 		},
	// 		{
	// 			AdditionalProperties: map[string]any{
	// 				"annotations": []any{
	// 				},
	// 				"runDimension": map[string]any{
	// 					"JobId": "84a3c493-0628-4b44-852f-ef5b3a11bdab",
	// 				},
	// 			},
	// 			InvokedBy: &armdatafactory.PipelineRunInvokedBy{
	// 				Name: to.Ptr("Manual"),
	// 				ID: to.Ptr("7c5fd7ef7e8a464b98b931cf15fcac66"),
	// 			},
	// 			LastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:39:51.216Z"); return t}()),
	// 			Message: to.Ptr(""),
	// 			Parameters: map[string]*string{
	// 				"OutputBlobNameList": to.Ptr("[\"exampleoutput.csv\"]"),
	// 			},
	// 			PipelineName: to.Ptr("examplePipeline"),
	// 			RunID: to.Ptr("16ac5348-ff82-4f95-a80d-638c1d47b721"),
	// 			RunStart: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:39:49.274Z"); return t}()),
	// 			Status: to.Ptr("Cancelled"),
	// 	}},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { DataFactoryManagementClient } = require("@azure/arm-datafactory");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Query pipeline runs in the factory based on input filter conditions.
 *
 * @summary Query pipeline runs in the factory based on input filter conditions.
 * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
 */
async function pipelineRunsQueryByFactory() {
  const subscriptionId =
    process.env["DATAFACTORY_SUBSCRIPTION_ID"] || "12345678-1234-1234-1234-12345678abc";
  const resourceGroupName = process.env["DATAFACTORY_RESOURCE_GROUP"] || "exampleResourceGroup";
  const factoryName = "exampleFactoryName";
  const filterParameters = {
    filters: [
      {
        operand: "PipelineName",
        operator: "Equals",
        values: ["examplePipeline"],
      },
    ],
    lastUpdatedAfter: new Date("2018-06-16T00:36:44.3345758Z"),
    lastUpdatedBefore: new Date("2018-06-16T00:49:48.3686473Z"),
  };
  const credential = new DefaultAzureCredential();
  const client = new DataFactoryManagementClient(credential, subscriptionId);
  const result = await client.pipelineRuns.queryByFactory(
    resourceGroupName,
    factoryName,
    filterParameters,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Core.Expressions.DataFactory;
using Azure.Identity;
using Azure.ResourceManager.DataFactory.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.DataFactory;

// Generated from example definition: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
// this example is just showing the usage of "PipelineRuns_QueryByFactory" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://zcusa.951200.xyz/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this DataFactoryResource created on azure
// for more information of creating DataFactoryResource, please refer to the document of DataFactoryResource
string subscriptionId = "12345678-1234-1234-1234-12345678abc";
string resourceGroupName = "exampleResourceGroup";
string factoryName = "exampleFactoryName";
ResourceIdentifier dataFactoryResourceId = DataFactoryResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, factoryName);
DataFactoryResource dataFactory = client.GetDataFactoryResource(dataFactoryResourceId);

// invoke the operation and iterate over the result
RunFilterContent content = new RunFilterContent(DateTimeOffset.Parse("2018-06-16T00:36:44.3345758Z"), DateTimeOffset.Parse("2018-06-16T00:49:48.3686473Z"))
{
    Filters =
    {
    new RunQueryFilter(RunQueryFilterOperand.PipelineName,RunQueryFilterOperator.EqualsValue,new string[]
    {
    "examplePipeline"
    })
    },
};
await foreach (DataFactoryPipelineRunInfo item in dataFactory.GetPipelineRunsAsync(content))
{
    Console.WriteLine($"Succeeded: {item}");
}

Console.WriteLine($"Succeeded");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

az datafactory pipeline-run query-by-factory --factory-name "exampleFactoryName" --filters operand="PipelineName" operator="Equals" values="examplePipeline" --last-updated-after "2018-06-16T00:36:44.3345758Z" --last-updated-before "2018-06-16T00:49:48.3686473Z" --resource-group "exampleResourceGroup"

Click here to learn more about the Azure CLI command.

Exempelsvar

Statuskod:: 200

Date: Sat, 16 Jun 2018 00:40:01 GMT
X-Content-Type-Options: nosniff
x-ms-ratelimit-remaining-subscription-reads: 14989
x-ms-request-id: 2f955e10-c6df-45a7-97d4-81acdb8540cd
x-ms-correlation-request-id: 2f955e10-c6df-45a7-97d4-81acdb8540cd

{
  "value": [
    {
      "runId": "2f7fdb90-5df1-4b8e-ac2f-064cfa58202b",
      "pipelineName": "examplePipeline",
      "parameters": {
        "OutputBlobNameList": "[\"exampleoutput.csv\"]"
      },
      "invokedBy": {
        "id": "80a01654a9d34ad18b3fcac5d5d76b67",
        "name": "Manual"
      },
      "runStart": "2018-06-16T00:37:44.6257014Z",
      "runEnd": "2018-06-16T00:38:12.7314495Z",
      "durationInMs": 28105,
      "status": "Succeeded",
      "message": "",
      "lastUpdated": "2018-06-16T00:38:12.7314495Z",
      "annotations": [],
      "runDimension": {
        "JobId": "79c1cc52-265f-41a5-9553-be65e736fbd3"
      }
    },
    {
      "runId": "16ac5348-ff82-4f95-a80d-638c1d47b721",
      "pipelineName": "examplePipeline",
      "parameters": {
        "OutputBlobNameList": "[\"exampleoutput.csv\"]"
      },
      "invokedBy": {
        "id": "7c5fd7ef7e8a464b98b931cf15fcac66",
        "name": "Manual"
      },
      "runStart": "2018-06-16T00:39:49.2745128Z",
      "runEnd": null,
      "durationInMs": null,
      "status": "Cancelled",
      "message": "",
      "lastUpdated": "2018-06-16T00:39:51.216097Z",
      "annotations": [],
      "runDimension": {
        "JobId": "84a3c493-0628-4b44-852f-ef5b3a11bdab"
      }
    }
  ]
}

Definitioner

Name	Description
CloudError	Objektet som definierar strukturen för ett Azure Data Factory felsvar.
PipelineRun	Information om en pipelinekörning.
PipelineRunInvokedBy	Innehåller entitetsnamn och ID som startade pipelinekörningen.
PipelineRunsQueryResponse	En listpipeline körs.
RunFilterParameters	Frågeparametrar för listkörningar.
RunQueryFilter	Frågefilteralternativ för listkörningar.
RunQueryFilterOperand	Parameternamn som ska användas för filter. Tillåtna operander för att fråga pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för att fråga aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType och Status, och för frågeutlösarkörningar är TriggerName, TriggerRunTimestamp och Status.
RunQueryFilterOperator	Operator som ska användas för filter.
RunQueryOrder	Sorteringsordning för parametern.
RunQueryOrderBy	Ett objekt för att ange ordning efter alternativ för listkörningar.
RunQueryOrderByField	Parameternamn som ska användas för order by. Tillåtna parametrar att sortera efter för pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd och Status; för utlösarkörningar är TriggerName, TriggerRunTimestamp och Status.

CloudError

Objektet som definierar strukturen för ett Azure Data Factory felsvar.

Name	Typ	Description
error.code	string	Felkod.
error.details	CloudError[]	Matris med ytterligare felinformation.
error.message	string	Felmeddelande.
error.target	string	Egenskapsnamn/sökväg i begäran som är associerad med fel.

PipelineRun

Information om en pipelinekörning.

Name	Typ	Description
durationInMs	integer	Varaktigheten för en pipelinekörning.
invokedBy	PipelineRunInvokedBy	Entitet som startade pipelinekörningen.
isLatest	boolean	Anger om den återställda pipelinekörningen är den senaste i gruppen.
lastUpdated	string	Den senast uppdaterade tidsstämpeln för pipelinekörningshändelsen i ISO8601 format.
message	string	Meddelandet från en pipelinekörning.
parameters	object	Den fullständiga eller partiella listan över parameternamn, värdepar som används i pipelinekörningen.
pipelineName	string	Pipelinenamnet.
runDimensions	object	Körningsdimensioner som genereras av pipelinekörning.
runEnd	string	Sluttiden för en pipelinekörning i ISO8601 format.
runGroupId	string	Identifierare som korrelerar alla återställningskörningar för en pipelinekörning.
runId	string	Identifierare för en körning.
runStart	string	Starttiden för en pipelinekörning i ISO8601 format.
status	string	Status för en pipelinekörning. Möjliga värden: Queued, InProgress, Succeeded, Failed, Canceling, Cancelled

PipelineRunInvokedBy

Innehåller entitetsnamn och ID som startade pipelinekörningen.

Name	Typ	Description
id	string	ID för entiteten som startade körningen.
invokedByType	string	Typen av entitet som startade körningen.
name	string	Namnet på entiteten som startade pipelinekörningen.
pipelineName	string	Namnet på pipelinen som utlöste körningen, om sådan finns.
pipelineRunId	string	Körnings-ID:t för pipelinen som utlöste körningen, om det finns några.

PipelineRunsQueryResponse

En listpipeline körs.

Name	Typ	Description
continuationToken	string	Fortsättningstoken för att hämta nästa sida med resultat, om det finns några återstående resultat, annars null.
value	PipelineRun[]	Lista över pipelinekörningar.

RunFilterParameters

Frågeparametrar för listkörningar.

Name	Typ	Description
continuationToken	string	Fortsättningstoken för att hämta nästa sida med resultat. Null för första sidan.
filters	RunQueryFilter[]	Lista över filter.
lastUpdatedAfter	string	Tidpunkten då körningshändelsen uppdaterades i FORMATET ISO 8601.
lastUpdatedBefore	string	Tidpunkten då körningshändelsen uppdaterades i ISO 8601-format.
orderBy	RunQueryOrderBy[]	Lista över alternativet OrderBy.

RunQueryFilter

Frågefilteralternativ för listkörningar.

Name	Typ	Description
operand	RunQueryFilterOperand	Parameternamn som ska användas för filter. Tillåtna operander för att fråga pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för att fråga aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType och Status, och för frågeutlösarkörningar är TriggerName, TriggerRunTimestamp och Status.
operator	RunQueryFilterOperator	Operator som ska användas för filter.
values	string[]	Lista över filtervärden.

RunQueryFilterOperand

Parameternamn som ska användas för filter. Tillåtna operander för att fråga pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för att fråga aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType och Status, och för frågeutlösarkörningar är TriggerName, TriggerRunTimestamp och Status.

Name	Typ	Description
ActivityName	string
ActivityRunEnd	string
ActivityRunStart	string
ActivityType	string
LatestOnly	string
PipelineName	string
RunEnd	string
RunGroupId	string
RunStart	string
Status	string
TriggerName	string
TriggerRunTimestamp	string

RunQueryFilterOperator

Operator som ska användas för filter.

Name	Typ	Description
Equals	string
In	string
NotEquals	string
NotIn	string

RunQueryOrder

Sorteringsordning för parametern.

Name	Typ	Description
ASC	string
DESC	string

RunQueryOrderBy

Ett objekt för att ange ordning efter alternativ för listkörningar.

Name	Typ	Description
order	RunQueryOrder	Sorteringsordning för parametern.
orderBy	RunQueryOrderByField	Parameternamn som ska användas för order by. Tillåtna parametrar att sortera efter för pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd och Status; för utlösarkörningar är TriggerName, TriggerRunTimestamp och Status.

RunQueryOrderByField

Parameternamn som ska användas för order by. Tillåtna parametrar att sortera efter för pipelinekörningar är PipelineName, RunStart, RunEnd och Status. för aktivitetskörningar är ActivityName, ActivityRunStart, ActivityRunEnd och Status; för utlösarkörningar är TriggerName, TriggerRunTimestamp och Status.

Name	Typ	Description
ActivityName	string
ActivityRunEnd	string
ActivityRunStart	string
PipelineName	string
RunEnd	string
RunStart	string
Status	string
TriggerName	string
TriggerRunTimestamp	string