Skip to main content
100%

Gist 79872f318f741408f6c6a418c5104465

✓ Published0🌍 Public
Aabonello
Last edited Mar 15, 2026
Created on Mar 15, 2026

This example demonstrates how to modify a SQL Server table schema by converting the `Status` column from a bit data type to an NVARCHAR(50) field with a default value of 'Pending'. It shows the process of dropping the existing default constraint, altering the column type, and then re-adding a new constraint. The code uses SQL Server T-SQL commands such as `ALTER TABLE`, `DROP CONSTRAINT`, and `ADD CONSTRAINT` to achieve the migration. The example is based on a gist by abonello and references the `Orders` table from a SalesDB database, highlighting the foreign key relationship with the `Customers` table.

AI-generated description

Similar vizzes

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
58% 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
58% match
Loading thumbnail…

Add new column in PostgreSQL with a subquery and set a NOT NULL constraint

This example shows how to add a new column to an existing PostgreSQL table and populate it with values from another table using a subquery in an UPDATE statement. The SQL script begins by adding the `exp_id` column as type `text`, then updates it by joining `table1` with `table2` on the `gid` field to copy matching `exp_id` values. Finally, it alters the column to set a `NOT NULL` constraint and wraps all operations in a single transaction with `BEGIN` and `COMMIT` to ensure atomicity. The code relies on standard PostgreSQL DDL and DML commands without external APIs.

LLuisSevillano
54% 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…

Gist f227f5d1e19ba9632c805fd11e03a76a

This example demonstrates a minimal CRUD API for managing customer records, built with ASP.NET Core and Entity Framework Core. It defines endpoints for creating, reading, updating, and deleting customers, with each operation interacting with a SQL Server database via `AppDbContext`. The code includes commented-out seed data and console output for testing, while the active HTTP routes use `MapGet`, `MapPost`, `MapPut`, and `MapDelete` to return JSON results through `Results.Ok`, `Results.Created`, and `Results.NotFound`. Swagger UI is enabled in development to document the API endpoints.

Aabonello
52% match
Loading thumbnail…

Gist ec3b35b83d07ef1d37a4af819723842b

This example demonstrates how to set up a PostgreSQL foreign data wrapper for staging data access. It shows the process of creating a foreign server, mapping users, and importing an external schema into a local staging schema. The code uses the `postgres_fdw` extension, along with SQL commands such as `CREATE SERVER`, `CREATE USER MAPPING`, and `IMPORT FOREIGN SCHEMA`. It also includes a commented example of querying imported tables, like selecting from `staging.users` to create a local table. The approach relies on PostgreSQL’s FDW API to connect to a remote database and expose its tables locally.

XXXX
52% match
Loading thumbnail…

Gist 860389

This example visualizes the schema of a phpBB posts database table, showing its columns, data types, and indexing structure. It uses a custom layout to represent each field as a node, with primary key and foreign key relationships highlighted through color and grouping. The visualization is rendered using D3.js, likely with `d3.forceSimulation` or a similar layout algorithm, and the underlying data is read directly from the SQL `CREATE TABLE` statement in the gist file. The code parses the schema definitions to generate the graph, mapping attributes like keys and full-text indexes visually.

TTBD
52% match
Loading thumbnail…

the description for this gist

This gist provides a schema definition for a database table named `subscriptions_capturing_transaction`, detailing the columns, types, and constraints for storing subscription transaction data. The schema is written in the `.skema` format, a structured JSON-like syntax for defining database tables. It includes fields for transaction details such as amount, currency, card information, and status, as well as configuration options like increment, timestamp, and soft delete. The implementation appears to use a custom schema parser or generator that interprets the `skema` format to create the database structure.

TThanad
50% match