Power Query funkcijas un vaicājumu piemēri
Apvienojiet funkcijas, kuras ir pieejamas Cognite Data Fusion (REST API) connector for Power BI, ar Power Query. Tā varēsiet ienest un pārveidot datus ar, Cognite API, lai izveidotu pārskatu informācijas paneļus ar Microsoft Power BI un Microsoft Excel.
Šajā sadaļā aprakstītie līdzekļi noteiktiem lietotājiem pašlaik ir beta testēšanas stadijā un var tikt mainīti.
Kopējiet un pielāgojiet vaicājumus un Power Query funkcijas šajā lapā, lai tās atbilstu jūsu uzņēmuma vajadzībām.
Utilītprogrammas funkcijas
Pārvērst laikspiedolus no perioda un uz to
CDF resursu tipi gaida un atgriež laikspiedolus, izmantojot milisekundes kopš Unix perioda. Power Query nav metožu šī formāta automātiskai parsēšanai uz datetimezone tipu, ar ko būtu iespējams attēlot laika joslas laikspiedolus. CDF datu modeļi attēlo laikspiedolus, vienkāršiem laukiem izmantojot ISO 8601 formātu.
Lai mainītu formātu no datetimezone mainīgā uz milisekundēm kopš Unix perioda un no mainīgā datetimezone uz tekstu ISO 8601 formātā, izmantojiet zemāk norādītās funkcijas.
ConvertDateTimeZoneToMs
//
(dtz as datetimezone) as number =>
let
// Convert the input DateTimeZone to UTC
UtcDateTime = DateTimeZone.RemoveZone(DateTimeZone.SwitchZone(dtz, 0)),
// Define the Unix epoch start
UnixEpochStart = #datetime(1970, 1, 1, 0, 0, 0),
// Calculate the duration between the input date and Unix epoch start
Delta = UtcDateTime - UnixEpochStart,
// Convert duration to total milliseconds
TotalMilliseconds = Duration.TotalSeconds(Delta) * 1000
in
TotalMilliseconds
ConvertMsToDateTimeZone
(ms as number) as datetimezone =>
let
// Convert ms to seconds
SecondsSinceEpoch = ms / 1000,
// Create a duration
DurationSinceEpoch = #duration(0, 0, 0, SecondsSinceEpoch),
// Add duration to Unix epoch start to get UTC datetime
UnixEpochStart = #datetime(1970, 1, 1, 0, 0, 0),
UtcDateTime = UnixEpochStart + DurationSinceEpoch,
// Convert UTC datetime to local time zone
LocalDateTimeZone = DateTimeZone.From(UtcDateTime)
in
LocalDateTimeZone
ConvertDateTimeZoneToIso
(dtz as datetimezone) as text =>
let
// Use DateTimeZone.ToText with ISO 8601 format
Result = DateTimeZone.ToText(dtz, [Format="yyyy-MM-ddTHH:mm:sszzz", Culture="en-US"])
in
Result
Pievienot funkciju
Lai pievienotu jaunu funkciju pievienojumprogrammā Power Query, atlasiet Iegūt datus > Tukšs vaicājums un ierakstiet savu funkciju vai kopējiet kādu no tālāk norādītajām funkcijām.
Laika delta vērtības
Sākuma un beigu laikspiedolus nereti definē, pamatojoties uz laika delta vērtībām. Vērtības tiks atjauninātas pēc datu kopas atsvaidzināšanas. Zemāk redzamajā piemērā EndTime ir pašreizējais laiks un StartTime ir 7 dienas pirms EndTime. Šo piemēru varat pielāgot dažādām laika delta vērtībām.
CurrentTime = DateTimeZone.LocalNow(),
EndTime = CurrentTime,
StartTime = CurrentTime - #duration(7, 0, 0, 0)
Kopīgs GET pieprasījums
Ja no CDF ienesat datus, izmantojot GetCDF funkciju no CDF REST API connector for Power BI, jums ir jāizmanto vaicājuma parametri. Tā varēsiet pārnest filtrus, lai izvēlētos, kurus datus ienest.
Tālāk sniegtajā piemērā ir parādīts, kā varat pievienot externalIdPrefix un limit vaicājuma parametrus no /timeseries galapunkta uz URL, lai filtrētu datus servera pusē.
let
Source = GetCDF("/timeseries?externalIdPrefix=EVE&limit=1000")
in
Source
Kopīgs POST pieprasījums
Ja no CDF datus ienesat ar PostCDF funkciju, jums ir jāuzraksta pieprasījuma pamatteksts, lai izvēlētos ienesamos datus. Lai arī funkcijā var izmantot JSON pamatteksta attēlojumu, pamattekstu var rakstīt, arī izmantojot Power Query ieraksta datu tipu. Pēc tam to pirms vērtības nodošanas PostCDF funkcijai varēsiet pārveidot par JSON teksta datu tipu.
let
SpaceExternalId = "Geography",
ViewExternalId = "City",
ViewVersion = "1",
Body = [
sources = {
[
source = [
type = "view",
space = SpaceExternalId,
externalId = ViewExternalId,
version = ViewVersion
]
]
},
limit = 1000
],
BodyText = Text.FromBinary(Json.FromValue(Body)),
Source = PostCDF("/models/instances/list", BodyText)
in
Source
POST pamattekstu varat rakstīt arī manuāli – kā tekstu –, bet tad dubultpēdiņas (") nevarēsiet lietot ar citu dubultpēdiņu rakstzīmju kopu:
let
BodyText = "{""sources"": [{""source"": {""type"": ""view"", ""space"": ""Geography"", ""externalId"": ""City"", ""version"": ""1""}}], ""limit"": 1000}",
Source = PostCDF("/models/instances/list", BodyText)
in
Source
Ja POST pieprasījums ir jāizmanto vēlreiz, varat to pārveidot par Power Query funkciju. Piemērs:
(SpaceExternalId as text, ViewExternalId as text, ViewVersion as text) as table =>
let
Body = [
sources = {
[
source = [
type = "view",
space = SpaceExternalId,
externalId = ViewExternalId,
version = ViewVersion
]
]
},
limit = 1000
],
BodyText = Text.FromBinary(Json.FromValue(Body)),
Source = PostCDF("/models/instances/list", BodyText)
in
Source
Funkcijas nosaukumu varat definēt, ar peles labo pogu noklikšķinot uz ieraksta vaicājumu sarakstā Power Query redaktorā un izvēloties Pārdēvēt.
Ja iepriekš minētā funkcija ir nosaukta ListInstancesDMS, jaunā vaicājumā to varat iekļaut, ievadot lauku vērtības Power Query vai rakstot jaunu vaicājumu:
let
Source = ListInstancesDMS("Geography", "City", "1")
in
Source
GraphQL pieprasījumi
Ja datus no CDF ienesat, izmantojot GraphQL funkciju, jums ir jāuzraksta GraphQL pieprasījums, lai izvēlētos, kurus datus ienest no konkrēta datu modeļa. Ja lietojat šo funkciju, jums jānorāda space ārējais ID, view ārējais ID, view versija, izpildāmais GraphQL vaicājums un, ja nepieciešams, arī mainīgo kopa, kas jāizmanto vaicājumā.
Tālāk sniegtajā vaicājumā tiek izmantota GraphQL sintakse un mainīgie tiek nodoti kā JSON teksti. Ja vaicājumā izmantojat mainīgos, parametru noteikšana un izmantošana ar ārējām vērtībām būs vienkāršāka.
let
Source = GraphQL(
"cdf_idm",
"CogniteProcessIndustries",
"v1",
"query MyQuery($cursor: String, $endTime: Timestamp) {#(lf) listCogniteMaintenanceOrder(#(lf) first: 1000#(lf) after: $cursor#(lf) filter: {endTime: {gte: $endTime}}#(lf) ) {#(lf) items {#(lf) name#(lf) type#(lf) startTime#(lf) endTime#(lf) priority#(lf) }#(lf) pageInfo {#(lf) endCursor#(lf) hasNextPage#(lf) }#(lf) }#(lf)}",
"{""endTime"": ""2024-10-01T00:00:00+02:00""}"
)
in
Source
M valoda, ko izmanto Power Query, šobrīd neatbalsta daudzrindu virknes, tāpēc vaicājumam ir jābūt vienu rindu garam. #(lf) attēlo rindas pārnesuma rakstzīmi. Iepriekš sniegtajā piemērā vaicājums tika ielīmēts teksta apgabala laukā Power Query un mainīgie tika pārnesti kā JSON teksts. Ievērojiet, kā Power BI rindas pārnesumus pievienoja sākotnējam vaicājumam un formulēja to kā vienā rindiņā ietilpstošu tekstuālu mainīgo.
Tāpat varat rakstīt vaicājumu kā vairākus vienu rindu garus tekstus un izmantot Text.Combine funkciju, lai vaicājumam pievienotu rindas pārnesumu. Jūs varat definēt mainīgos kā Power Query ierakstus un pārvērst tos par JSON tekstu pirms to pārnešanas uz GraphQL funkciju. Piemēram, skatiet, kā ConvertDateTimeZoneToIso funkcija pārvērš datetimezone mainīgo par ISO 8601 formāta teksta attēlojumu un pēc tam pārnes to uz vaicājumu kā mainīgo.
let
// This could be a parameter or referenced from another query
EndTime = #datetimezone(2024, 10, 1, 0, 0, 0, 2, 0),
VariablesRecord = [
endTime = ConvertDateTimeZoneToIso(EndTime)
],
VariablesText = Text.FromBinary(Json.FromValue(VariablesRecord)),
Query = Text.Combine({
"query MyQuery($cursor: String, $endTime: Timestamp) {",
" listCogniteMaintenanceOrder(",
" first: 1000",
" after: $cursor",
" filter: {endTime: {gte: $endTime}}",
" ) {",
" items {",
" name",
" type",
" startTime",
" endTime",
" priority",
" }",
" pageInfo {",
" endCursor",
" hasNextPage",
" }",
" }",
"}"
}, "#(lf)"),
Data = GraphQL(
"cdf_idm",
"CogniteProcessIndustries",
"v1",
Query,
VariablesText
)
in
Data
Sarežģītāki piemēri
Atkarībā no Cognite API atbildes formas pastāv iespēja, ka datu iegūšanai un pārveidei būs nepieciešamas papildu Power Query pārveides. Kopējiet un pielāgojiet tālāk sniegtos piemērus, lai tie atbilstu jūsu uzņēmuma vajadzībām.
Iegūstiet sekvences rindas ar PostCDF funkciju
Tālāk norādītā Power Query funkcija no CDF ienes un apstrādā sekvences rindu datus, kas saistīti ar sekvences ārējo ID. Tas nosūta POST pieprasījumu, izgūst kolonnas informāciju, izvērš ligzdotos atbildes datus un pārkārto tos tabulas formātā. Funkcija pārveido datu tipu, noņem nevajadzīgos laukus un grupē datus pēc rindas. Rezultāts ir labi strukturēta tabula ar pareizi aizpildītām kolonnām.
(externalId as text) as table =>
let
RequestBody = "{""externalId"": """ & externalId & """, ""limit"": 10000}",
Response = PostCDF("/sequences/data/list", RequestBody),
// Extract columns information from the first page
FirstPage = Response{0},
Columns = FirstPage[columns],
ColumnNames = List.Transform(Columns, each [externalId]),
ColumnTypes = List.Transform(Columns, each
if [valueType] = "STRING" then type text else
if [valueType] = "DOUBLE" then type number else
if [valueType] = "LONG" then Int64.Type
else type any
),
// Extract the 'values' from each row
Rows = Table.ExpandListColumn(Response, "rows"),
ValuesTable = Table.ExpandRecordColumn(Rows, "rows", {"rowNumber", "values"}, {"rows.rowNumber", "rows.values"}),
RemoveColumns = Table.RemoveColumns(ValuesTable,{"id", "externalId", "columns", "nextCursor"}),
ExpandValues = Table.ExpandListColumn(RemoveColumns, "rows.values"),
// Group by rowNumber and create a record for each row
GroupedRows = Table.Group(ExpandValues, {"rows.rowNumber"}, {
{"RowData", (t) => Record.FromList(t[rows.values], ColumnNames)}
}),
// Expand the RowData column
ExpandRows = Table.ExpandRecordColumn(GroupedRows, "RowData", ColumnNames),
// Set column data types
FinalTable = Table.TransformColumnTypes(ExpandRows, List.Zip({ColumnNames, ColumnTypes}))
in
FinalTable
Lai izmantotu funkciju, veiciet tālāk norādītās darbības.
let
Source = RetrieveSequenceRows("sequence-externalId")
in
Source
Iegūstiet instances no DMS vaicājuma galapunkta ar PostCDF funkciju
Tālāk sniegtā Power Query funkcija izgūst un apstrādā datu modelēšanas gadījumus DMS vaicājumam. Tas atbildi segmentē, izgūst instances un paplašina ligzdotos datus.
(query as text) as table =>
let
FetchPage = (query as text, optional cursors as nullable record) as table =>
let
Query = Json.Document(query),
UpdatedQuery =
if cursors <> null then
let
// Get all field names of both records
QueryWithFields = Record.FieldNames(Query[with]),
QUerySelectFields = Record.FieldNames(Query[select]),
CursorsFields = Record.FieldNames(cursors),
// Find the intersection of field names
CommonFields = List.Intersect({QueryWithFields, QUerySelectFields, CursorsFields}),
// Create new records containing only the common fields
UpdatedQueryWithAndSelect = Record.TransformFields(
Query,
{
{"with", each Record.SelectFields(_, CommonFields)},
{"select", each Record.SelectFields(_, CommonFields)}
}
)
in
UpdatedQueryWithAndSelect
else
Query,
// Add cursors if they are provided
UpdatedQueryWithCursors =
if cursors <> null then
Record.AddField(UpdatedQuery, "cursors", cursors)
else
UpdatedQuery,
FinalBody = Text.FromBinary(Json.FromValue(UpdatedQueryWithCursors)),
Response = PostCDF("/models/instances/query", FinalBody)
in
Response,
// Helper function to create next cursor record from result table
CreateNextCursorRecordFromTable = (inputTable as table) as record =>
let
RecordsList = List.Transform(
Table.ToRecords(inputTable), each Record.FromList({[nextCursor]}, {[resultExpression]})
),
CombinedRecord = Record.Combine(RecordsList)
in
CombinedRecord,
// Helper function to check if all cursors are null
AllCursorsNull = (cursorsRecord as record) as logical =>
let
CursorValues = Record.ToList(cursorsRecord),
NullCount = List.Count(List.Select(CursorValues, each _ = null))
in
NullCount = List.Count(CursorValues),
// Helper function to aggregate items from all pages and convert to tables
AggregateResults = (results as list) as table =>
let
// Combine all tables
CombinedTable = Table.Combine(results),
// Group by resultExpression and convert items to tables
GroupedTable = Table.Group(
CombinedTable,
{"resultExpression"},
{
{
"items",
each
Table.FromRecords(
List.Combine(List.Transform([items], each if Value.Is(_, type list) then _ else {
_
}))
),
type table
}
}
)
in
GroupedTable,
// Main pagination logic
FetchAllPages = () as list =>
let
// Initialize accumulator
InitialAcc = [
results = {},
currentCursors = null,
hasMore = true
],
// Pagination function
PaginationFunction = (acc as record) =>
let
CurrentPage = FetchPage(query, acc[currentCursors]),
NextCursors = CreateNextCursorRecordFromTable(CurrentPage),
HasMoreResults = not AllCursorsNull(NextCursors) and Table.RowCount(CurrentPage) > 0,
UpdatedResults = List.Combine({acc[results], {CurrentPage}})
in
[
results = UpdatedResults,
currentCursors = NextCursors,
hasMore = HasMoreResults
],
// Keep fetching until no more results
AllResults = List.Generate(
() => InitialAcc, each _[hasMore], each PaginationFunction(_), each _[results]
),
// Get the final list of results
FinalResults = List.Last(AllResults)
in
FinalResults,
// Execute pagination and combine results
AllPages = FetchAllPages(),
FinalTable = AggregateResults(AllPages)
in
FinalTable
Lai izmantotu funkciju, veiciet tālāk norādītās darbības.
let
Query = [
with = [
cities = [
nodes = [
filter = [
hasData = {
[
space = "Geography",
externalId = "City",
version = "1",
#"type" = "view"
]
}
],
chainTo = "destination",
direction = "outwards"
]
],
countries = [
nodes = [
filter = [
hasData = {
[
space = "Geography",
externalId = "Country",
version = "1",
#"type" = "view"
]
}
],
chainTo = "destination",
direction = "outwards"
]
]
],
select = [
cities = [
sources = {
[
source = [
space = "Geography",
externalId = "City",
version = "1",
#"type" = "view"
],
properties = {
"name"
}
]
}
],
countries = [
sources = {
[
source = [
space = "Geography",
externalId = "Country",
version = "1",
#"type" = "view"
],
properties = {
"name"
}
]
}
]
]
],
QueryText = Text.FromBinary(Json.FromValue(Query)),
Source = QueryDMS(QueryText)
in
Source
Lai no hasData netiktu ienestas visas instances, pievienojiet filtrus, piemēram, iepriekšējā piemērā norādīto CDF filtru.
Ienesiet laika rindas datu punktus ar PostCDF funkciju
Tālāk norādītā Power Query funkcija izgūst un apstrādā apkopotos laika rindu datu punktus, kas saistīti ar laika rindu laika diapazonā. Tā pārveido vietējās laika joslas ievades UTC formātā, lai veidotu CDF API pieprasījumus, atbalsta vairākas apkopošanas funkcijas un pielāgotu granularitāti, kā arī apstrādā datu segmentēšanu. Pēc tam funkcija atgrieztos UTC laikspiedolus pārveido atpakaļ vietējā laika joslā, paplašina ligzdoto API atbildi un izvada labi noformētu tabulu ar pareizi aizpildītām kolonnām. Tā ietver arī vietējos laikspiedolus un decimālās apkopotās vērtības.
Piemērā laikspiedolu pārveidošanā ir izmantotas ConvertDateTimeZoneToMs un ConvertMsToDateTimeZone funkcijas.
(
item as record,
start as datetimezone,
optional end as nullable datetimezone,
optional aggregates as nullable text,
optional granularity as nullable text,
optional targetUnit as nullable text,
optional targetUnitSystem as nullable text,
optional timeZone as nullable text
) =>
let
// Function to detect query type based on item record structure
DetectQueryType = (item as record) =>
let
Fields = Record.FieldNames(item),
HasId = List.Contains(Fields, "id"),
HasExternalId = List.Contains(Fields, "externalId"),
HasSpace = List.Contains(Fields, "space"),
FieldCount = List.Count(Fields),
QueryType =
if HasId and not HasExternalId and not HasSpace and FieldCount = 1 then
"id"
else if HasExternalId and not HasId and not HasSpace and FieldCount = 1 then
"externalId"
else if HasExternalId and HasSpace and not HasId and FieldCount = 2 then
"instanceId"
else
Error.Record(
"Invalid item content", "The item record does not match any supported query type", item
)
in
QueryType,
// Detect query type
queryType = DetectQueryType(item),
// Determine limit based on presence of aggregates
limit = if aggregates <> null then 10000 else 100000,
// Convert aggregates from comma-separated string to list format accepted by the API
AggregatesList = Text.Split(aggregates, ","),
AggregatesTrimmedList = List.Transform(AggregatesList, each Text.Trim(_)),
StartMs = Number.Round(ConvertDateTimeZoneToMs(start)),
EndMs = Number.Round(ConvertDateTimeZoneToMs(end)),
// Function to fetch a single page of data
FetchPage = (cursor as nullable text) =>
let
// Build body item
bodyItem =
if queryType = "id" then
[id = Record.Field(item, "id")]
& (if targetUnit <> null then [targetUnit = targetUnit] else [])
& (if targetUnitSystem <> null then [targetUnitSystem = targetUnitSystem] else [])
& (if cursor <> null then [cursor = cursor] else [])
else if queryType = "externalId" then
[externalId = Record.Field(item, "externalId")]
& (if targetUnit <> null then [targetUnit = targetUnit] else [])
& (if targetUnitSystem <> null then [targetUnitSystem = targetUnitSystem] else [])
& (if cursor <> null then [cursor = cursor] else [])
else if queryType = "instanceId" then
[ instanceId = [ space = Record.Field(item, "space"), externalId = Record.Field(item, "externalId") ] ]
& (if targetUnit <> null then [targetUnit = targetUnit] else [])
& (if targetUnitSystem <> null then [targetUnitSystem = targetUnitSystem] else [])
& (if cursor <> null then [cursor = cursor] else [])
else
error "Invalid query type",
// Build request body
body = [
items = {bodyItem},
limit = limit,
ignoreUnknownIds = true,
start = Text.From(StartMs)
]
& (if end <> null then [end = Text.From(EndMs)] else [])
& (if aggregates <> null then [aggregates = AggregatesTrimmedList] else [])
& (if granularity <> null then [granularity = granularity] else [])
& (if timeZone <> null then [timeZone = timeZone] else []),
Response = PostCDF("/timeseries/data/list", Text.FromBinary(Json.FromValue(body))),
// Try to fetch the cursor from the first item in the response
FirstItem =
if Type.Is(Value.Type(Response), type table) and Table.RowCount(Response) > 0 then
Table.First(Response)
else
null,
NextCursor = if FirstItem <> null then Record.FieldOrDefault(FirstItem, "nextCursor", null) else null,
// Handles empty response and extracts data points when present
FinalItemsList =
if Table.HasColumns(Response, "datapoints") then
let
// Clean up the response table
ColumnsToRemove = {"nextCursor", "isStep", "unit"},
ColumnsPresent = List.Intersect({Table.ColumnNames(Response), ColumnsToRemove}),
CleanedTable = Table.RemoveColumns(Response, ColumnsPresent),
// Expand the "datapoints" column
ExpandedDatapointsList = Table.ExpandListColumn(CleanedTable, "datapoints"),
// Handles the case where the list of "datapoints" is empty
FinalDataPointsList =
if List.NonNullCount(ExpandedDatapointsList[datapoints]) > 0 then
let
// Extract a sample record to determine available fields dynamically
SampleRecord = ExpandedDatapointsList[datapoints]{0},
AvailableFields = Record.FieldNames(SampleRecord),
// Expand the "datapoints" records using the available fields
ExpandedDatapointsRecords = Table.ExpandRecordColumn(
ExpandedDatapointsList, "datapoints", AvailableFields, AvailableFields
),
DataPointsList = Table.ToRecords(ExpandedDatapointsRecords)
in
DataPointsList
else
{}
in
FinalDataPointsList
else
Table.ToRecords(Response)
in
{FinalItemsList, NextCursor},
// Recursive function to accumulate all pages of data
AccumulateData = (cursor as nullable text, accumulatedItems as list) =>
let
CurrentPage = FetchPage(cursor),
NewItems = CurrentPage{0},
NextCursor = CurrentPage{1},
UpdatedAccumulatedItems = accumulatedItems & NewItems,
Result =
if NextCursor <> null then
@AccumulateData(NextCursor, UpdatedAccumulatedItems)
else
UpdatedAccumulatedItems
in
Result,
// Fetch all data
AllItems = AccumulateData(null, {}),
// Convert the accumulated items to a table
ConvertToTable =
if List.IsEmpty(AllItems) then
Table.FromList({}, Splitter.SplitByNothing(), null, null, ExtraValues.Error)
else
Table.FromList(AllItems, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
// Expand the table column and convert timestamps
ExpandedTable =
if not Table.IsEmpty(ConvertToTable) and Table.HasColumns(ConvertToTable, "Column1") then
let
TmpTable = Table.ExpandRecordColumn(
ConvertToTable, "Column1", Record.FieldNames(ConvertToTable{0}[Column1])
),
// timestamp should be always present when there are datapoints
FixType = Table.TransformColumnTypes(TmpTable, {{"timestamp", Int64.Type}}),
ParseTimestamp = Table.TransformColumns(FixType, {"timestamp", each ConvertMsToDateTimeZone(_)}),
ParsedWithType = Table.TransformColumnTypes(ParseTimestamp, {{"timestamp", type datetimezone}}),
// check if the timeseries is of type string
FirstEntry = ParsedWithType{0},
IsString = FirstEntry[isString],
CleanedTable = Table.RemoveColumns(ParsedWithType, {"isString"}),
// Convert aggregate/value columns to decimal number
ValuesAsDecimal =
if aggregates <> null then
Table.TransformColumnTypes(
CleanedTable, List.Transform(AggregatesTrimmedList, each {_, type number})
)
else if IsString then
CleanedTable
else
Table.TransformColumnTypes(
CleanedTable, List.Transform({"value"}, each {_, type number})
),
// Check if "id" column is present and convert to integer
IdAsInteger =
if Table.HasColumns(ValuesAsDecimal, "id") then
Table.TransformColumnTypes(ValuesAsDecimal, {{"id", Int64.Type}})
else
ValuesAsDecimal
in
IdAsInteger
else
ConvertToTable
in
ExpandedTable
Šī funkcija ir sarežģītāka nekā iepriekšējie piemēri un var izpildīt dažādus scenārijus, veicot segmentēšanu, datu tipa pārveidošanu un ligzdoto datu paplašināšanu. Lai izmantotu funkciju, veiciet tālāk norādītās darbības.
let
Source = RetrieveDataPoints(
[ externalId = "EVE-TI-FORNEBU-01-3" ],
#datetimezone(2024, 10, 1, 0, 0, 0, 2, 0),
#datetimezone(2024, 10, 13, 10, 0, 0, 2, 0),
"average,max,min",
"1d",
null,
"SI",
"Europe/Oslo"
)
in
Source
Pamatojoties uz šo funkciju, varat izveidot citu funkciju, lai iterētu laika rindu ārējo ID sarakstu un iekļautu rezultātus lielā tabulā. Saraksts var būt kolonna citā tabulā, kur jūs, piemēram, filtrējat laika rindas. Šo funkciju varat pielāgot, lai iterētu iekšējo ID vai instanču ID sarakstu.
(
externalIds as list,
start as datetimezone,
end as datetimezone,
aggregates as text,
granularity as text,
optional targetUnitSystem as nullable text,
optional timeZone as nullable text
) =>
let
// Iterate over each externalId and get corresponding table
TablesList = List.Transform(
externalIds,
each RetrieveDataPoints(
[ externalId = _ ],
start,
end,
aggregates,
granularity,
null,
targetUnitSystem,
timeZone
)
),
// Combine all tables into one
CombinedTable = Table.Combine(TablesList)
in
CombinedTable
Lai izmantotu funkciju, veiciet tālāk norādītās darbības.
let
Source = RetrieveDataPointsMultipleTs(
{"EVE-TI-FORNEBU-01-2", "EVE-TI-FORNEBU-01-3"},
#datetimezone(2024, 10, 1, 0, 0, 0, 2, 0),
#datetimezone(2024, 10, 13, 10, 0, 0, 2, 0),
"average,max,min",
"1d",
"SI",
"Europe/Oslo"
)
in
Source
- Microsoft:
Power Querydokumentācija