Gist e9eac02df35654daa5d0

100%

Gist e9eac02df35654daa5d0

✓ Published0🌍 Public

Last edited Dec 14, 2013

Created on Aug 2, 2014

This example demonstrates a minimal data pipeline that reads JSON data and inserts it into a local SQLite database. The script, `jsonToSqlite.py`, loads a JSON file containing a list of objects, extracts the first object’s `"foo"` and `"bar"` fields, and writes those two values as a single row into a table named `table_name`. It uses the standard `json` module for parsing and `sqlite3` for database operations, creating a table and inserting the data with a parameterized `execute` call. The visualization shows only the code structure, not a graphical output, highlighting the simple ETL pattern of extracting, transforming, and loading data.

AI-generated description

Similar vizzes

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

67% match

Loading thumbnail…

Gist 66b1a9a31dce76682837c3fd4d9a468b

This example demonstrates how to query JSONB data directly in PostgreSQL and flatten it into a relational result set. The code creates a table with a JSONB column, inserts two sample rows, and then uses two different query approaches: the `->>` operator to extract scalar fields as text, and the `jsonb_to_record` function with a column definition list to cast JSON values into typed columns (text and integer). The example highlights both methods for accessing nested JSON data, showing the explicit extraction syntax versus the more structured record-expansion technique, all within a single SQL file.

JJonasHeylen

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

64% match

Loading thumbnail…

SQLite cursus Udemy

This example demonstrates how to manage SQLite databases through Python, contrasting two distinct approaches. It shows the creation, insertion, and querying of database tables using both the SQLAlchemy ORM and the raw `sqlite3` module. The code highlights SQLAlchemy’s declarative table definitions, `db.insert()` for record insertion, and `pd.read_sql_query` to load query results into a pandas DataFrame. It also presents `sqlite3` with cursor-based operations like `execute()` for CRUD functions and parameterized queries for email lookups. The visualization is purely programmatic, with no graphical output, focusing instead on code patterns for database interaction.

FFrieseWoudloper

60% match

Loading thumbnail…

Gist be32a2ac117700d3dbde6b0824367ba5

This example demonstrates how to create a simple database table visualization from a SQL schema definition. The code defines a `Demo` table with three columns—`ID`, `Key`, and `Value`—and shows how to map those column types and constraints into a visual entity-relationship style diagram. Using the provided `CREATE TABLE` statement as the data source, the visualization renders each column as a node, with the primary key and nullable attributes indicated through distinct visual encodings. The implementation leverages `d3.forceSimulation` for the node layout and `d3.geoPath` for any geometric rendering, while relying on standard DOM elements for interactivity. No additional behavior beyond the table’s structural representation is implied.

HHugoberry

59% match

Loading thumbnail…

Gist 05471e1965de232f4434a8624c8949dc

This example demonstrates a minimal Express.js server that serves player data from a SQLite database, exposing endpoints for retrieving all players or looking up a single player by email. The backend uses `express`, `body-parser`, and the `sqlite3` library, with an async utility function (`getPlayers` or `getPlayerByEmail`) handling database queries. Although no charting or visualization library is present, the code illustrates a typical API structure for feeding data to a front-end visualization. The root route returns a plain JSON message, while `/players` and `/playerByEmail` respond with JSON arrays or objects, showing how raw data would be delivered for subsequent graphical rendering.

WWill Carter

59% match

Loading thumbnail…

Gist d2f55e96546318a1e8e393d423ea36e9

This example shows a SQL query that transfers data from one Excel sheet to another, creating a new table in a separate workbook file. The visualization demonstrates how data can be exported or copied between spreadsheet locations using an embedded query. The code uses the `SELECT * INTO` syntax with an `[Excel 8.0;DATABASE=...]` connection string, specifying the destination file path and sheet name. The query pulls all records from the source sheet and writes them to the target workbook, illustrating a straightforward data-migration pattern. The rendering approach relies on the database driver’s handling of the Excel file format, with no additional charting or graphics libraries involved.

HHugoberry

59% match

Loading thumbnail…

Script for updating a database of the Citibike JSON feed

This example demonstrates a script that keeps a Citibike station and bike database current by parsing the live Citibike JSON feed. It shows how to update PostgreSQL records through Django models, capturing the feed’s execution time as separate date and time fields. The code uses the `requests` library to fetch the JSON, `datetime` to reformat timestamps, and Django’s `get_or_create` to add or retrieve station and bike entries. It also handles station ID changes by matching on station names, ensuring consistent data linkage across updates.

JJoshAddington

56% match