Sometimes you just need an SQL table filled with some natural numbers. Here's a simple & brute-force solution that will work on ANY SQL dialect. It returns a table with an arbitrary number of natural numbers, provided this number is equal to 10.000... I used this on ExaSOL, where most Oracle / MSSQL magic does not work.

100%

Sometimes you just need an SQL table filled with some natural numbers. Here's a simple & brute-force solution that will work on ANY SQL dialect. It returns a table with an arbitrary number of natural numbers, provided this number is equal to 10.000... I used this on ExaSOL, where most Oracle / MSSQL magic does not work.

✓ Published0🌍 Public

Last edited Aug 23, 2013

Created on Aug 23, 2013

This example shows a SQL table named `natural_numbers` containing a single column `n` with integer values. The brute-force solution generates a sequence of natural numbers from 1 to 10000 by explicitly listing every value in a single `INSERT INTO` statement, making it compatible with any SQL dialect, including Exasol, where common alternatives like Oracle's `CONNECT BY` or MSSQL's `WITH` recursion may not work. The table is created with a simple `CREATE TABLE` statement followed by an exhaustive `VALUES` list, providing a straightforward, if verbose, method for generating a range of natural numbers without relying on dialect-specific features. The visualization highlights the impracticality of this approach for large ranges, while demonstrating a universal fallback technique.**Title:** Brute-Force Natural Numbers Table for Any SQL Dialect **Description:** This example demonstrates a remarkably simple, albeit verbose, SQL approach to generating a table of natural numbers from 1 to 10,000. Instead of relying on dialect-specific functions or recursive CTEs—which often fail on platforms like ExaSOL—the author manually constructs the table using a single `INSERT` statement with 10,000 explicit value tuples. The result is a portable, dependency-free way to create a numbers table, though it requires copying a very long list of values. A humorous take on a common developer need, this gist highlights the trade-off between universal compatibility and brute-force practicality. **Files:** - `natural_numbers.sql` — contains the full `CREATE TABLE` and `INSERT` statements to generate the sequence.This example from adewes showcases a delightfully pragmatic SQL workaround: generating a sequence of natural numbers in ExaSOL, where common recursive or procedural methods aren't available. The `natural_numbers.sql` file uses a purely brute-force approach, explicitly inserting values from 1 to 10,000 with a single `INSERT` statement. While verbose, this solution is guaranteed to run on virtually any SQL dialect, making it a useful fallback when more elegant methods fail. The visualization gallery entry would emphasize this as a humorous yet functional illustration of SQL portability constraints and creative problem-solving—a "sometimes you just need" workaround that trades elegance for universal compatibility.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 066cc1deef3173351f9d6b358b93d78b

This visualization generates synthetic timestamp data from year strings using a SQL function that randomly selects a point between January 1 and December 31 of the given year. The example demonstrates how to create randomized temporal values for testing or simulation purposes, with the function `random_time_from_year_string` accepting a year as text and returning a timestamp. The code leverages PostgreSQL's SQL language features, including type casting and arithmetic on timestamp intervals, while using the `random()` function to produce the uniform distribution across the year. The rendering approach is not specified, as the example focuses solely on the data generation logic within the SQL query.

Aandrewbt

54% match

Loading thumbnail…

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

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.

HHugoberry

52% match

Loading thumbnail…

SQL builder sketches for node.js and node-postgres

Three variations of a JavaScript SQL query builder sketch generate `UPDATE` statements with parameterized placeholders for the node-postgres driver. The code demonstrates both a single-call function with positional arguments and a fluent, chainable interface named `UPDATE` that supports `.SET()`, `.WHERE()`, and `.RETURNING()` methods. Common utilities like `Object.keys`, `Array.map`, and `assert` manage column-value pairs, while the chained version tracks placeholder numbering against accumulated `values`. A third, prototype-free variant shows an alternative closure-based approach. The examples illustrate different API design patterns for safely composing dynamic SQL.

RRandomEtc

52% match

Loading thumbnail…

crude combination solution with dynamic programming

This example prints a Pascal-style table of combinations for all values of n and k from 0 up to a user-supplied n. It shows the numerical result of each combination, formatted as “nCk = value”, in rows where k increments from 0 to n. The code uses a memoized factorial function with a preallocated list (`factorial_array`) to store intermediate results, implementing dynamic programming to avoid recomputation. It reads two integers from standard input and validates them, then iterates through nested `for` loops to generate and display each combination via the `combination` function, which relies on the factorial cache.

Aanemochore

51% match

Loading thumbnail…

example script to upload any csv and run sql queries against the data in the browser

This example loads a user-selected CSV file through an HTML file input and stores its contents in an in-browser SQL database using the sql.js library, which compiles SQLite to JavaScript. It infers each column’s data type—integer, float, boolean, date, or text—from the first non-empty value, then dynamically creates a table and inserts rows. After import, the code runs a sample SQL query with a bound parameter (e.g., counting rows by a last name) and logs the result to the console, demonstrating how to execute arbitrary SQL against uploaded tabular data entirely client-side.

Aandrewfulrich

51% match

Loading thumbnail…

Simple database

This example shows how to create a simple relational database with two tables, Customers and Orders, using raw SQL. It demonstrates the use of IDENTITY columns for auto-generated primary keys and FOREIGN KEY constraints to enforce referential integrity between the tables. The code also includes a JOIN query that combines customer names with their corresponding order details, illustrating basic data retrieval without an ORM. The example relies on standard SQL Server syntax and T-SQL commands, including CREATE TABLE, CONSTRAINT, and SELECT with JOIN.

Aabonello

50% match

Loading thumbnail…

Functional SQL: https://www.codewars.com/kata/545434090294935e7d0010ab

This example recreates a functional SQL query engine in JavaScript, translating a Codewars kata into a working API. The code defines a `query` object with chainable methods like `select`, `from`, `where`, `groupBy`, `having`, and `orderBy`, mirroring SQL clause semantics. It performs cross joins across multiple arrays, applies filtering via nested callback arrays, and builds nested group structures using plain objects and recursive traversal. The final `execute` method returns mapped rows, demonstrating how relational query concepts can be implemented without external libraries, relying solely on native array methods and object literals.

MMunishkin

50% 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

50% match