API Reference

Complete API documentation for Sleet ORM.

Overview

Sleet ORM provides a fluent, type-safe interface for database operations. The API is organized into several key areas:

• Schema Definition - Define your database structure
• Query Builder - Build and execute queries
• Column Types - Available column types and modifiers
• Operators - Comparison and logical operators

Schema Definition

sl.table(name, columns)

Define a table schema.

Parameters:

• name (string) - Table name
• columns (table) - Column definitions

Returns: Table schema object

local players = sl.table('players', {
    id = sl.serial().primaryKey(),
    name = sl.varchar(255).notNull()
})

Column Methods

All column types support these chainable methods:

.primaryKey()

Mark column as primary key.

id = sl.serial().primaryKey()

.notNull()

Add NOT NULL constraint.

name = sl.varchar(255).notNull()

.unique()

Add UNIQUE constraint.

email = sl.varchar(100).unique()

.default(value)

Set default value.

active = sl.boolean().default(true)
money = sl.int().default(1000)

.defaultNow()

Set default to current timestamp (for timestamp columns).

created_at = sl.timestamp().defaultNow()

.comment(text)

Add column comment.

name = sl.varchar(255).comment('Player display name')

.references(column)

Create foreign key reference.

player_id = sl.int().references(players.id)

.softDelete()

Mark column as soft delete timestamp.

deleted_at = sl.timestamp().softDelete()

.onUpdate(value)

Auto-update column on row changes.

updated_at = sl.timestamp().onUpdate(sl.sql('NOW()'))

Database Connection

sl.connect()

Create database connection using oxmysql.

Returns: Database connection object

local db = sl.connect()

Query Building

The query builder provides methods for SELECT, INSERT, UPDATE, and DELETE operations.

Basic Structure

-- SELECT
db.select([columns])
  .from(table)
  [.where(condition)]
  [.orderBy(column, direction)]
  [.limit(count)]
  [.offset(count)]
  .execute()

-- INSERT  
db.insert(table)
  .values(data)
  .execute()

-- UPDATE
db.update(table)
  .set(data)
  [.where(condition)]
  .execute()

-- DELETE
db.delete(table)
  [.where(condition)]
  .execute()

Raw SQL

sl.sql(query, params?)

Create raw SQL expression.

Parameters:

• query (string) - SQL expression
• params (table, optional) - Parameters for placeholders

Returns: Raw SQL object

-- In SELECT
sl.sql('COUNT(*) as total')

-- With parameters
sl.sql('money + ?', { 500 })

-- In WHERE
sl.sql('created > DATE_SUB(NOW(), INTERVAL 7 DAY)')

Error Handling

All query operations can throw errors. Use pcall() for error handling:

local success, result = pcall(function()
    return db.select()
        .from(s.players)
        .where(sl.eq(s.players.id, playerId))
        .execute()
end)

if success then
    -- Process result
else
    print('Query failed:', result)
end

Debugging

.toSQL()

Get generated SQL and parameters without executing.

local query = db.select()
    .from(s.players)
    .where(sl.eq(s.players.active, true))

local sql, params = query.toSQL()
print('SQL:', sql)
print('Params:', json.encode(params))

Next Steps

• Learn about specific Column Types
• Explore the Query Builder in detail
• Check available Operators
• See practical Examples