A relational database stores structured information in named tables. Each table has columns that describe what kind of information is stored and rows that represent individual records. SQL is the language commonly used to define, read, change, and organize that data.

This first SQL lesson stays deliberately narrow. Before learning SELECT, filtering, joins, indexes, or transactions, you need a clean mental model of a database, a table, a row, a column, and a data type. Those five ideas are the foundation for everything that follows in the SQL track.

1. What A Relational Database Is

A database is an organized collection of data managed by software. A relational database management system, or RDBMS, organizes much of that data as relations. In everyday SQL work, a relation is usually represented as a table. PostgreSQL describes itself as a relational database management system and explains that a table is a named collection of rows with a fixed set of named columns.

This differs from a plain text file because the database engine understands the structure of the data. It can enforce data types, apply constraints, coordinate many users, recover transactions, build indexes, and answer queries without requiring an application to manually scan and parse every record.

Relational databases remain central to modern software even as applications become more distributed. BitcoinVersus.Tech recently covered Supabase and Turso building database infrastructure for AI-created applications. The scale and deployment model may change, but the basic idea of storing structured records in database tables remains important.

2. Tables, Rows, And Columns

A table has a name and a defined set of columns. Think of a table called miners. Each row could represent one mining machine. The columns could describe the machine’s identifier, model, hashrate, power draw, and current status.

miners

id | model       | hashrate_th | power_w | status
1  | S21         | 200         | 3500    | online
2  | S19j Pro    | 104         | 3068    | repair
3  | Avalon A11  | 78          | 3420    | online

The columns describe attributes shared by every row in that table. The rows contain the actual records. PostgreSQL’s current table documentation notes that a table’s columns have defined names and types while the number of rows can change as data is added or removed.

A table is not the same thing as a spreadsheet even though both can look like grids. A spreadsheet is primarily a document for interactive calculation and presentation. A relational table is part of a database system that applies a formal schema and can be queried, constrained, joined, indexed, and changed transactionally.

3. Columns Have Data Types

Every column has a data type. The type tells the database what kind of value belongs in that column and what operations make sense for it. Common types include integers, decimal numbers, text, dates, timestamps, and Boolean values.

id            INTEGER
model         TEXT
hashrate_th   NUMERIC
power_w       INTEGER
online        BOOLEAN

Data types matter because structured data should carry meaning. A power value stored as an integer can participate in arithmetic. A date stored as a date can be sorted and compared as a date. A free-form text field is flexible, but that flexibility also means the database can enforce less about its contents.

This is one reason database tables differ from loosely structured formats. JSON can also represent structured data, but a relational table usually begins with a declared schema that tells the database exactly which columns exist and what types they accept.

4. A Schema Describes Structure

The word schema is used in several related ways, but at the beginner level it is useful to think of schema as the defined structure of the database: table names, column names, data types, and later constraints and relationships.

A schema gives the database a contract. If a column is intended to contain whole-number rack counts, the design should say so. If a field is meant to store a timestamp, the database should know that it is a timestamp rather than arbitrary text.

Good schema design does not mean predicting every future requirement. It means making today’s data model explicit enough that programs and people can reason about it. Later lessons will add primary keys, foreign keys, constraints, normalization, indexes, and transactions to this foundation.

5. Create A First Table

SQL uses CREATE TABLE to define a new table. The statement names the table, then lists its columns and their types inside parentheses.

CREATE TABLE miners (
    id INTEGER,
    model TEXT,
    hashrate_th NUMERIC,
    power_w INTEGER,
    online BOOLEAN
);

Read this statement from the outside inward. CREATE TABLE miners says to create a table named miners. Inside the parentheses, each line defines one column. The comma separates one column definition from the next. The semicolon ends the SQL statement.

This table is intentionally incomplete from a production-design perspective. It has no primary key constraint, no required fields, no validation rules, and no relationship to any other table. Those are later concepts. The goal here is simply to understand that SQL can define the shape of stored data.

The official PostgreSQL table-basics documentation uses the same pattern: a table name followed by column names and data types. PostgreSQL’s tutorial also introduces relational concepts before moving into table creation, rows, queries, joins, and later features.

6. Tables Can Represent Different Kinds Of Things

A strong relational design usually separates different kinds of things into different tables instead of forcing everything into one giant table. A mining application might eventually have tables for miners, sites, repairs, and measurements. A web application might have users, orders, products, and payments.

The database becomes relational when these tables can be connected through meaningful values and constraints. You will learn primary and foreign keys later in this track. For now, the important idea is simply that different tables can represent different entity types while still belonging to one database.

Modern services may hide much of the database administration behind APIs and managed platforms. BitcoinVersus.Tech’s API explainer is useful background because many applications talk to a backend service, which then reads and writes database tables on the application’s behalf.

7. Row Order Is Not Guaranteed

A beginner mistake is to assume the database permanently stores rows in the order they were entered. SQL does not guarantee that. PostgreSQL explicitly notes that row order is unspecified unless a query requests sorting.

That means visual position is not identity. The row shown first today is not necessarily the row shown first tomorrow. Later, ORDER BY will give you explicit control over presentation order, and keys will give records stable identifiers.

Turso is joining @supabase.

Together, we're building the database platform for the agentic era: everything agents need, from lightweight databases to Postgres at petabyte scale.

More details in thread. 👇 pic.twitter.com/pcqoN5k9tP

— Turso (@tursodatabase) October 2, 2026

8. Build A Small Table Lab

Use any SQL environment you already have available, such as SQLite, PostgreSQL, or a trusted browser-based SQL playground. Create this table exactly as written:

CREATE TABLE racks (
    rack_id INTEGER,
    room TEXT,
    capacity_kw NUMERIC,
    active BOOLEAN
);

Before inserting anything, identify the structure in plain language. The table is named racks. It has four columns. Two columns represent whole-number or decimal numeric values, one represents text, and one represents a true-or-false state.

Now create a second table without copying the example. Use a subject you understand well: network switches, GPUs, books, vehicles, batteries, tools, or game characters. Give the table four or five columns and choose a sensible type for each column. The point is not to build a complete application yet. The point is to practice translating a real-world concept into a table definition.

9. Common Beginner Mistakes

• Confusing a database with a table: one database can contain many tables.
• Confusing a row with a column: a row is one record; a column is one attribute shared across records.
• Using text for everything: choose types that match the meaning of the data.
• Treating row position as identity: SQL does not promise permanent row order.
• Putting unrelated entities in one huge table: separate concepts usually deserve separate tables.
• Trying to learn every SQL command at once: first understand the data model; querying comes next.

10. Exercises

1. Define database, table, row, column, and data type in one sentence each.
2. Design a table named servers with at least five columns.
3. Choose which columns in your servers table should be numeric, text, Boolean, or timestamp values.
4. Write a CREATE TABLE statement for a table named batteries.
5. Explain why a relational table is not simply a spreadsheet saved on a server.
6. Give an example of two different tables that might belong to the same application.
7. Explain why row order should not be used as a permanent identifier.
8. Find one field in a real system that would be badly represented as free-form text and choose a better data type.

11. Knowledge Check

1. What does RDBMS stand for?
2. In beginner SQL terms, what is a relation usually represented as?
3. What is the difference between a row and a column?
4. Why does a column have a data type?
5. What SQL command creates a table?
6. Does SQL guarantee the order of rows when no explicit sort is requested?
7. Can one database contain multiple tables?
8. What does a schema describe at a basic level?
9. Why is storing every value as text usually a poor design choice?
10. What is the next SQL skill after understanding relational tables in this curriculum?

12. Answers

1. Relational Database Management System.
2. A table.
3. A row is one record; a column is one named attribute or field shared by the table’s records.
4. The type constrains what values belong in the column and determines how the database can interpret and operate on them.
5. CREATE TABLE.
6. No. Row order is unspecified unless the query explicitly requests sorting.
7. Yes.
8. The defined structure of the data, including tables, columns, types, and later constraints and relationships.
9. Because numbers, dates, Booleans, and other typed values have semantics and operations that arbitrary text does not provide reliably.
10. SELECT, which retrieves data from tables.

13. Official Reference And Prior Reading

• PostgreSQL Documentation — The SQL Language Tutorial
• PostgreSQL Documentation — Table Basics
• Supabase Acquires Turso to Give Every AI Agent Its Own Database
• What Is JSON? How Software Stores and Exchanges Structured Data
• What Is an API? How Software Talks to Software

14. What You Should Remember

A relational database organizes structured data into tables. Tables contain rows and columns. Columns have names and data types. A schema defines the structure. SQL gives you commands for defining and working with that structure.

Do not worry yet about joins, optimization, transactions, or advanced schema design. The next canonical SQL lesson is OSSQL.002: SELECT, where the focus moves from defining a table to retrieving data from it.

BitcoinVersus.Tech

Editor’s Note: SQL implementations differ in details. When syntax or supported data types differ between SQLite, PostgreSQL, MySQL, SQL Server, or another database engine, confirm the behavior against the documentation for the system you are using.

BitcoinVersus.Tech publishes open technical education across programming, semiconductors, electronics, networking, robotics, data centers, operating systems, firmware, and infrastructure.

BitcoinVersus.Tech provides educational information for general informational purposes.