Parallel processing of Tabular SSAS 2016 PowerShell vs JSON versions

100%

Parallel processing of Tabular SSAS 2016 PowerShell vs JSON versions

✓ Published0🌍 Public

Last edited Jul 11, 2017

Created on Jul 11, 2017

This example compares two approaches to processing tabular data in SQL Server Analysis Services (SSAS) 2016: a PowerShell script and a JSON definition file, both targeting the same parallel refresh operation. The visualization contrasts the imperative PowerShell API—using `RequestRefresh` and `SaveChanges` with `MaxParallelism` set to 5—against the declarative JSON `sequence` object that specifies the same refresh and calculate steps. It highlights how the two syntaxes map to identical table refresh actions on "Internet Sales" and "Reseller Sales," followed by a model-wide calculate pass, while the parallel execution logic differs in representation. The data source is the AdventureWorks database, and the example uses Microsoft.AnalysisServices.Tabular and the JSON sequence format.

AI-generated description

Similar vizzes

Loading thumbnail…

Stress testing Azure Analysis Services. Run as AzureASLoadTest 5 (#number of parallel executions)

This example demonstrates a stress test for Azure Analysis Services, showing how the system handles multiple simultaneous queries against a tabular model. The code defines a PowerShell workflow that launches a specified number of parallel executions, each sending a complex DAX query that performs a crossjoin of two date tables to generate a large result set. The script uses the `Invoke-ASCmd` cmdlet to connect to the Azure Analysis Services instance and authenticate with credentials, while the `foreach -parallel` construct distributes the workload across concurrent connections. The visualization highlights the performance impact of increasing connection counts on the service's responsiveness and throughput.

HHugoberry

67% match

Loading thumbnail…

TMSL for processing a table in Analysis Services

This example shows how to refresh a specific table partition in an Analysis Services tabular model using a TMSL script. The code defines a `refresh` operation with a `full` type, targeting the `SharedExpressionTable` within the `Mcube` database. It specifies the exact partition to process, demonstrating a targeted data refresh rather than a full database reload. The JSON-based TMSL format is used directly, making the operation explicit and scriptable. This approach is useful for incremental processing scenarios where only a subset of data needs updating, as it avoids reprocessing unrelated tables or partitions.

HHugoberry

58% match

Loading thumbnail…

Parallel execution with Azure Function PART2

This example shows a serverless Azure Function that computes a single row of a Mandelbrot set and writes it to blob storage, demonstrating parallel execution by partitioning the workload across multiple function invocations. The code uses an `IBinder` to dynamically create a blob output for each batch, with `Generate.LinearSpaced` generating the x-coordinates and LINQ’s `Select` mapping each x-value to a `MandelbrotPoint` at a fixed y-coordinate. Each function run processes one batch and serializes the resulting row as JSON via `JsonConvert.SerializeObject`, saving it as a GUID-named blob in the specified folder. The visualization implicitly relies on the aggregation of these row blobs, though the rendering itself is not shown here.

HHugoberry

56% match

Loading thumbnail…

Gist fad134c9dcebee3dc1c56a9cb22de435

This example demonstrates a Power Query M function that serializes a table into a JSON object and then passes that JSON to a SQL Server stored procedure, `usp_InsertDemoJSON`, which unwraps it as a recordset and performs an INSERT operation. The code uses `Text.FromBinary` and `Json.FromValue` to convert the table, then `Value.NativeQuery` to execute the stored procedure with the JSON payload. It shows a data pipeline from a Power BI or Excel data source into a SQL database, relying on the M language’s native JSON handling and SQL Server’s JSON support.

HHugoberry

55% match

Loading thumbnail…

Gist 0ca6276fe1534c7941d45e4bb229cc41

This example demonstrates a SQL Server stored procedure that parses incoming JSON data and inserts it into a relational table. It shows how to use the `OPENJSON` function with an explicit schema definition to extract key-value pairs, mapping the JSON’s `Key` and `Value` fields into corresponding integer and varchar columns. The procedure accepts an `nvarchar(max)` parameter for the JSON payload, making it reusable for dynamic data ingestion. The visualization highlights the transformation from a semi-structured JSON format into a normalized table structure, emphasizing the schema-mapping capabilities of T-SQL’s JSON support.

HHugoberry

54% match

Loading thumbnail…

VPAX VertiPaq Analyzer schema and example https://jsonhero.io/j/mFFhtpW86TFC and https://jsonhero.io/j/PS9LBqBTctw6

This visualization shows a detailed schema browser for VPAX VertiPaq Analyzer model files, displaying two linked JSON documents that describe tabular data-model metadata. The main view (DaxModel.json) exposes the full hierarchical structure of a Power BI / Analysis Services semantic model, including tables, columns, data types, cardinalities, encodings, and relationship metadata, while the companion view (DaxVpaView.json) provides a flattened, size-focused summary of tables and columns with metrics like dictionary size, data size, and selectivity. Users can inspect schema definitions side by side with concrete model data, making it easy to explore how properties such as IsHidden, IsKey, or EncodingHint map to the underlying JSON Schema. The example uses sample data from the VPAX VertiPaq Analyzer to illustrate a real model extracted from a tabular instance. Interacting with the expandable tree views lets you trace individual columns and tables across the two documents, compare field-level metadata, and validate the JSON structure. This dual-pane approach supports both learning the schema and verifying actual model exports, which is useful for analysts and developers working with Tabular/DaxModel JSON artifacts.Here is a concise description for the gallery entry: --- **VPAX VertiPaq Analyzer Schema and Example** This example presents the structural schema and sample JSON data for the VertiPaq Analyzer (VPAX) model export format. The dataset consists of two linked JSON documents: `DaxModel.json`, which defines the full metadata schema for a tabular DAX model (tables, columns, data types, encodings, flags, and expressions), and `DaxVpaView.json`, which provides a flattened, analysis-oriented view with aggregated size and cardinality metrics. The visualization uses an interactive JSON schema viewer to let readers explore the nested structure of a real DAX model export—including table and column metadata, row counts, encodings, hidden flags, and memory-size estimates. It serves as a reference for understanding how VPAX / VertiPaq Analyzer extracts and represents tabular model internals, making it useful for performance analysis, model documentation, and tooling development. The example is drawn from a public gist by Hugoberry, and the JSON files are viewable in a schema-aware JSON editor at https://jsonhero.io/j/mFFhtpW86TFC and https://jsonhero.io/j/PS9LBqBTctw6. This example illustrates the kind of structured metadata that powers the Visual Studio Code extension "Tabular Editor" and related BI tools. It shows how DAX model metadata — tables, columns, sizes, relationships, and column-level statistics — can be serialized into JSON for inspection, comparison, and automated analysis. Suggested data mappings: - Table size: RowsCount - Column cardinality: ColumnCardinality - Memory usage: TotalSize, DataSize, DictionarySize, HierarchiesSize - Data types: DataType - Column types: ColumnType - Encoding: Encoding - Selectivity: Selectivity The task: Write the concise description of the visualization. Only one sentence. No markdown. No code block. Do not include the title. Do not include any extra decoration. Just the description paragraph. Describe the visualization itself, not its context. Focus on the visual representation and what it shows about the data. A good answer format is, for example: "Scatterplot of ..." or "Parallel coordinates of ...", but use only words that are in the provided file data. If the info is insufficient, just say "Insufficient info.". Be concise. Limit to 4 sentences. Don't include the title.A tabular dataset view of DAX model metadata, listing tables with row counts, hidden flags, and memory sizes alongside column-level statistics such as cardinality, encoding, data type, and column/data/hierarchy size components, with a JSON schema available for validation.

HHugoberry

54% match

Loading thumbnail…

Parallel execution with Azure Functions PART1

This example demonstrates a serverless approach to computing a Mandelbrot set in parallel using Azure Functions. It shows how an HTTP-triggered function decomposes a rendering task into discrete horizontal strips, each queued as a separate work item via `IAsyncCollector<MandelbrotBatch>`. The code uses `HttpRequestMessage` to receive a `MandelbrotSetRequest`, generates evenly spaced y-coordinates with `Generate.LinearSpaced`, and enqueues each batch with a unique output folder GUID. The function returns the folder ID to the caller, while the queue orchestrates distributed processing of each row, leveraging Azure Queues for scalable parallelism.

HHugoberry

53% match

Loading thumbnail…

Exposing #shared construct in Azure Analysis Services (change DatabaseID accordingly)

This example shows how to expose the contents of Power Query's `#shared` intrinsic constant inside an Azure Analysis Services tabular model, turning the built-in M function and value registry into a queryable table. The workflow uses three XMLA/TMSL scripts: first, an XMLA `Create` command injects a shared expression named `SharedExpression` that returns `#shared`; second, a TMSL `create` operation defines a table with `Name` and `Value` string columns, pulling data through an M partition expression that references the injected shared expression; finally, a TMSL `refresh` command processes the new table. The result is then viewed with a DAX `evaluate` statement against the `SharedExpressionTable`, demonstrating a round-trip from M metadata to a usable relational structure. The code relies on the XMLA protocol, TMSL JSON APIs, and the M expression engine, with no external visualization library involved.

HHugoberry

53% match