Data Types (Postgres)

Embar provides comprehensive support for PostgreSQL data types. All types are imported from embar.column.pg and embar.column.common.

Integer Types

Integer

Standard integer type.

from embar.column.common import Integer
from embar.table import Table

class Product(Table):
    quantity: Integer = Integer()

Generates:

"quantity" INTEGER

SmallInt

Small integer type for values from -32768 to 32767.

from embar.column.pg import SmallInt

class Product(Table):
    stock: SmallInt = SmallInt()

Generates:

"stock" SMALLINT

BigInt

Large integer type for values beyond the standard integer range.

from embar.column.pg import BigInt

class Analytics(Table):
    views: BigInt = BigInt()

Generates:

"views" BIGINT

Serial Types

Serial types are auto-incrementing integers.

Serial

Auto-incrementing integer.

from embar.column.pg import Serial

class User(Table):
    id: Serial = Serial(primary=True)

Generates:

"id" SERIAL

SmallSerial

Auto-incrementing small integer.

from embar.column.pg import SmallSerial

class Tag(Table):
    id: SmallSerial = SmallSerial(primary=True)

Generates:

"id" SMALLSERIAL

BigSerial

Auto-incrementing big integer.

from embar.column.pg import BigSerial

class Event(Table):
    id: BigSerial = BigSerial(primary=True)

Generates:

"id" BIGSERIAL

Text Types

Text

Variable-length text with no limit.

from embar.column.common import Text

class Post(Table):
    content: Text = Text()

Generates:

"content" TEXT

Varchar

Variable-length text with optional length limit.

from embar.column.pg import Varchar

class User(Table):
    username: Varchar = Varchar(length=50)

Generates:

"username" VARCHAR(50)

Without a length limit:

class User(Table):
    bio: Varchar = Varchar()

Generates:

"bio" VARCHAR

Char

Fixed-length character type.

from embar.column.pg import Char

class Country(Table):
    code: Char = Char(length=2)

Generates:

"code" CHAR(2)

Numeric Types

Numeric

Arbitrary precision decimal type with configurable precision and scale.

from embar.column.pg import Numeric

class Product(Table):
    price: Numeric = Numeric(precision=10, scale=2)

Generates:

"price" NUMERIC(10, 2)

With precision only:

class Product(Table):
    score: Numeric = Numeric(precision=5)

Generates:

"score" NUMERIC(5)

PgDecimal

Alias for Numeric (DECIMAL is an alias for NUMERIC in PostgreSQL).

from embar.column.pg import PgDecimal

class Invoice(Table):
    total: PgDecimal = PgDecimal(precision=12, scale=2)

Generates:

"total" DECIMAL(12, 2)

Float

Real floating point type.

from embar.column.common import Float

class Measurement(Table):
    temperature: Float = Float()

Generates:

"temperature" REAL

DoublePrecision

Double precision floating point type.

from embar.column.pg import DoublePrecision

class Calculation(Table):
    result: DoublePrecision = DoublePrecision()

Generates:

"result" DOUBLE PRECISION

Boolean

Boolean type for true/false values.

from embar.column.pg import Boolean

class User(Table):
    active: Boolean = Boolean(default=True)

Generates:

"active" BOOLEAN

JSON Types

Json

JSON data stored as text.

from embar.column.pg import Json

class Config(Table):
    settings: Json = Json()

Generates:

"settings" JSON

Jsonb

Binary JSON with indexing support. Recommended over Json for most use cases.

import asyncio

from embar.db.pg import AsyncPgDb
from embar.column.pg import Jsonb

class User(Table):
    metadata: Jsonb = Jsonb()

# Usage
async def main():
    db = AsyncPgDb(...)
    user = User(metadata={"theme": "dark", "language": "en"})
    await db.insert(User).values(user)

Generates:

"metadata" JSONB

Date and Time Types

Date

Calendar date (year, month, day).

from datetime import date
from embar.column.pg import Date

class Event(Table):
    event_date: Date = Date()

# Usage
event = Event(event_date=date(2025, 1, 15))

Generates:

"event_date" DATE

Time

Time of day without date.

from datetime import time
from embar.column.pg import Time

class Schedule(Table):
    start_time: Time = Time()

# Usage
schedule = Schedule(start_time=time(9, 30))

Generates:

"start_time" TIME

Timestamp

Date and time without timezone.

from datetime import datetime
from embar.column.pg import Timestamp

class Post(Table):
    created_at: Timestamp = Timestamp()

# Usage
post = Post(created_at=datetime.now())

Generates:

"created_at" TIMESTAMP

Interval

Time interval (duration).

from datetime import timedelta
from embar.column.pg import Interval

class Task(Table):
    duration: Interval = Interval()

# Usage
task = Task(duration=timedelta(hours=2, minutes=30))

Generates:

"duration" INTERVAL

Enum Types

PostgreSQL enums require defining both the enum type and the column type.

from enum import auto
from embar.column.pg import EmbarEnum, EnumCol, PgEnum

class StatusEnum(EmbarEnum):
    PENDING = auto()
    ACTIVE = auto()
    COMPLETED = auto()

class StatusPgEnum(PgEnum[StatusEnum]):
    name: str = "status_enum"
    enum: type[StatusEnum] = StatusEnum

class Task(Table):
    status: EnumCol[StatusEnum] = EnumCol(StatusPgEnum)

# Usage
async def main():
    db = AsyncPgDb(...)
    task = Task(status="ACTIVE")
    await db.insert(Task).values(task)

The enum must be included in migrations:

async def main():
    db = AsyncPgDb(...)
    await db.migrate([Task], enums=[StatusPgEnum])

Generates:

CREATE TYPE status_enum AS ENUM ('PENDING', 'ACTIVE', 'COMPLETED');

And for the column:

"status" status_enum

Common Column Options

All column types support these options:

Primary Key

class User(Table):
    id: Integer = Integer(primary=True)

Not Null

class User(Table):
    email: Text = Text(not_null=True)

Default Values

class User(Table):
    status: Text = Text(default="active")
    created_at: Timestamp = Timestamp(default=datetime.now())

Custom Column Name

class User(Table):
    email: Text = Text("user_email")