Skip to main content
SimilarExport ZIP
100%

Generate a dummy table in Power Query. It contains 1M records of form [key=number, value=GUID]

✓ Published0🌍 Public
HHugoberry
Last edited Apr 10, 2017
Created on Apr 9, 2017

This example demonstrates how to generate a dummy dataset of one million records in Power Query, with each record containing a numeric key and a globally unique identifier (GUID) value. The visualization shows the structure and volume of the data rather than aggregating or summarizing it. The code uses the Power Query M language, specifically the `Table.FromRecords` and `List.Generate` functions, to programmatically create the table. `Text.NewGuid()` supplies the unique values, while the key increments sequentially from zero up to 999,999. This approach highlights how Power Query can efficiently produce large, synthetic datasets for testing or performance analysis without external data sources.

AI-generated description

Similar vizzes

Loading thumbnail…

Power Query incremental load example for querypower.com

This example demonstrates a Power Query incremental load setup for querypower.com, showing how a simple list source is transformed step by step. The code defines a query named `Query1` that generates a numeric range from 0 to 9, serving as the foundational data source. It uses the Power Query M language’s `let` and `in` syntax to structure the transformation pipeline, with `Source` assigned the output of `{0..9}`. The visualization highlights the initial stage of an incremental refresh pattern, where only new or changed rows would be processed in subsequent runs. The example focuses on the query definition itself, not on external libraries or rendering, as the M code contains no visual output or advanced APIs.

HHugoberry
62% match
Loading thumbnail…

Concept for inserting data into SQL Server

This example demonstrates a concept for inserting data into SQL Server by using Power Query’s M language. It shows a table creation script for a demo table with an identity column, a key, and a value, followed by an M query that iterates over a list of key-value pairs. The code uses `List.Accumulate` to loop through the pairs and calls `OleDb.DataSource` with a SQL `INSERT` statement for each iteration, referencing the SQLOLEDB provider to connect to a local database. The result is the total number of affected records from the inserts, though the actual inserted rows are not visualized or returned in the output.

HHugoberry
61% match
Loading thumbnail…

Power Query incremental load from querypower.com

This example shows a minimal Power Query incremental-load setup derived from a querypower.com gist. It defines a table named `QueryLog.m` with two columns—`SESSION_LAST_COMMAND_START_TIME` and `SESSION_LAST_COMMAND`—both initially empty. The code uses the Power Query M language’s `let` and `#table` functions to declare the schema and seed an empty table. No external JavaScript libraries or Canvas/WebGL APIs are involved; the visualization is purely a static representation of the query structure. The rendering approach is not shown, only the M code that establishes the log table for tracking session command timestamps and actions.

HHugoberry
60% match
Loading thumbnail…

Gist faec7eb6c03589ff608bab991699407b

This example demonstrates how to generate and execute a dynamic SQL script in Power Query (M language) to bulk-insert data into a SQL Server table using a table-valued parameter (TVP). It builds a textual TVP declaration and populates it by chunking source rows into sets of 1,000 entries, then constructs a multi-statement script that inserts each chunk and calls a stored procedure. The code relies on M functions like `Table.TransformRows`, `List.Generate`, `Text.Combine`, and `Value.NativeQuery` to programmatically assemble and run the query. The visualization highlights the data flow from a source table to a SQL stored procedure, emphasizing the chunking logic and the use of native query execution.

HHugoberry
60% match
Loading thumbnail…

Writing 10M lines of a query result to a table in Power Query via R

This example demonstrates how to write 10 million rows of a query result to a CSV file from Power Query by invoking an R script. It shows the integration of Power Query’s table generation with R’s file-export capabilities, specifically using the `R.Execute` function to run `write.csv` on a dataset. The Power Query code creates a list of numbers from 1 to 10,000,000 via `{1..10000000}`, converts it to a table with `Table.FromList`, and passes that table as the `dataset` parameter to the R script. The R script then writes the data to `d:\Downloads\out.csv`.

HHugoberry
59% match
Loading thumbnail…

Dummy table serialized as XML binary

This example shows a Power Query routine that serializes a two-column table into a single binary XML document. The code transforms each row into a `<row>` element containing `<key>` and `<value>` tags, then wraps all rows in a root `<table>` element. It relies on the `Table.TransformRows` function to iterate over the input table, while `Binary.Combine` and `Text.ToBinary` concatenate the textual XML fragments into a single binary output. The data source is an in-memory table named `dummy`, and the result is a well-formed XML representation of that table.

HHugoberry
58% match
Loading thumbnail…

Generating Mandelbrot set in Power Query

This example renders the Mandelbrot set entirely within Power Query by generating a 1080-point sequence with `List.Generate`, mapping each point to the complex plane, and iterating the classic Mandelbrot formula to compute escape values. It visualizes the resulting 2D grid of iteration counts as a static bitmap, relying on Power Query’s built-in table and chart capabilities rather than external libraries. The code exposes a compact, functional approach to fractal generation, directly showing how iteration-based math translates into a visual image without specialized graphics APIs.

HHugoberry
57% match
Loading thumbnail…

JSON to Table in Power Query M

This example demonstrates a Power Query M function that converts arbitrary JSON data into a structured table. It shows the step-by-step process of detecting expandable record and list columns, then iteratively expanding them until all nested objects are flattened. The code uses core M APIs such as `Table.ExpandRecordColumn`, `Table.ExpandListColumn`, `List.Accumulate`, and `List.Generate` to handle consistent and inconsistent column types. The source is a JSON object or list, which is transformed into a final normalized table through a loop that checks column types and applies the appropriate expansion method.

HHugoberry
57% match