dbsqlc

package
v0.40.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 2, 2026 License: MPL-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DBTX 

type DBTX interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	PrepareContext(context.Context, string) (*sql.Stmt, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

type JobCancelParams 

type JobCancelParams struct {
	Now               *string
	CancelAttemptedAt string
	ID                int64
}

type JobCountByAllStatesRow added in v0.24.0 

type JobCountByAllStatesRow struct {
	State string
	Count int64
}

type JobCountByQueueAndStateRow added in v0.24.0 

type JobCountByQueueAndStateRow struct {
	Queue          string
	CountAvailable int64
	CountRunning   int64
}

type JobDeleteBeforeParams 

type JobDeleteBeforeParams struct {
	CancelledFinalizedAtHorizon string
	CompletedFinalizedAtHorizon string
	DiscardedFinalizedAtHorizon string
	Max                         int64
	QueuesExcludedEmpty         bool
	QueuesExcluded              []string
}

type JobGetAvailableParams 

type JobGetAvailableParams struct {
	Now       *string
	Queue     string
	MaxToLock int64
}

type JobGetStuckParams 

type JobGetStuckParams struct {
	StuckHorizon string
	Max          int64
}

type JobInsertFastNoReturningParams 

type JobInsertFastNoReturningParams struct {
	Args         interface{}
	CreatedAt    *string
	Kind         string
	MaxAttempts  int64
	Metadata     interface{}
	Priority     int64
	Queue        string
	ScheduledAt  *string
	State        string
	Tags         interface{}
	UniqueKey    []byte
	UniqueStates *int64
}

type JobInsertFastParams 

type JobInsertFastParams struct {
	ID           *int64
	Args         interface{}
	CreatedAt    *string
	Kind         string
	MaxAttempts  int64
	Metadata     interface{}
	Priority     int64
	Queue        string
	ScheduledAt  *string
	State        string
	Tags         interface{}
	UniqueKey    []byte
	UniqueStates *int64
}

type JobInsertFullParams 

type JobInsertFullParams struct {
	Args         interface{}
	Attempt      int64
	AttemptedAt  *string
	AttemptedBy  []byte
	CreatedAt    *string
	Errors       []byte
	FinalizedAt  *string
	Kind         string
	MaxAttempts  int64
	Metadata     interface{}
	Priority     int64
	Queue        string
	ScheduledAt  *string
	State        string
	Tags         interface{}
	UniqueKey    []byte
	UniqueStates *int64
}

type JobKindListParams added in v0.24.0 

type JobKindListParams struct {
	Match   string
	After   string
	Exclude []string
	Max     int64
}

type JobRescueParams 

type JobRescueParams struct {
	Error       interface{}
	FinalizedAt *string
	ScheduledAt time.Time
	State       string
	ID          int64
}

type JobRetryParams 

type JobRetryParams struct {
	Now *string
	ID  int64
}

type JobScheduleGetCollisionParams 

type JobScheduleGetCollisionParams struct {
	ID        int64
	UniqueKey []byte
}

type JobScheduleGetEligibleParams 

type JobScheduleGetEligibleParams struct {
	Now *string
	Max int64
}

type JobScheduleSetDiscardedParams 

type JobScheduleSetDiscardedParams struct {
	Now *string
	ID  []int64
}

type JobSetMetadataIfNotRunningParams 

type JobSetMetadataIfNotRunningParams struct {
	MetadataUpdates interface{}
	ID              int64
}

type JobSetStateIfRunningParams 

type JobSetStateIfRunningParams struct {
	State               string
	AttemptDoUpdate     bool
	Attempt             int64
	ErrorsDoUpdate      bool
	Error               interface{}
	Now                 *string
	FinalizedAtDoUpdate bool
	FinalizedAt         *time.Time
	MetadataDoMerge     bool
	MetadataUpdates     interface{}
	ScheduledAtDoUpdate bool
	ScheduledAt         time.Time
	ID                  int64
}

type JobUpdateFullParams added in v0.29.0 

type JobUpdateFullParams struct {
	AttemptDoUpdate     bool
	Attempt             int64
	AttemptedAtDoUpdate bool
	AttemptedAt         *time.Time
	AttemptedByDoUpdate bool
	AttemptedBy         interface{}
	ErrorsDoUpdate      bool
	Errors              interface{}
	FinalizedAtDoUpdate bool
	FinalizedAt         *time.Time
	MaxAttemptsDoUpdate bool
	MaxAttempts         int64
	MetadataDoUpdate    bool
	Metadata            interface{}
	StateDoUpdate       bool
	State               string
	ID                  int64
}

type JobUpdateParams 

type JobUpdateParams struct {
	MetadataDoMerge bool
	Metadata        interface{}
	ID              int64
}

type LeaderAttemptElectParams 

type LeaderAttemptElectParams struct {
	LeaderID string
	Now      *string
	TTL      string
}

type LeaderAttemptReelectParams 

type LeaderAttemptReelectParams struct {
	Now       *string
	TTL       string
	ElectedAt string
	LeaderID  string
}

type LeaderInsertParams 

type LeaderInsertParams struct {
	ElectedAt *string
	Now       *string
	ExpiresAt *string
	TTL       string
	LeaderID  string
}

type LeaderResignParams added in v0.35.0 

type LeaderResignParams struct {
	ElectedAt string
	LeaderID  string
}

type Queries 

type Queries struct {
}

func New 

func New() *Queries

func (*Queries) IndexExists 

func (q *Queries) IndexExists(ctx context.Context, db DBTX, index string) (bool, error)

func (*Queries) JobCancel 

func (q *Queries) JobCancel(ctx context.Context, db DBTX, arg *JobCancelParams) (*RiverJob, error)

Differs by necessity from other drivers because SQLite doesn't support `UPDATE` inside CTEs so we can't retry if running but select otherwise. Instead, the driver uses a transaction to optimisticaly try an update, but perform a subsequent fetch on a not found to return the right status.

I had to invert the last 'AND' expression below (was an 'ANT NOT) due to an sqlc bug. Something about sqlc's SQLite parser cannot detect a parameter inside an `AND NOT`.

func (*Queries) JobCountByAllStates added in v0.24.0 

func (q *Queries) JobCountByAllStates(ctx context.Context, db DBTX) ([]*JobCountByAllStatesRow, error)

func (*Queries) JobCountByQueueAndState added in v0.24.0 

func (q *Queries) JobCountByQueueAndState(ctx context.Context, db DBTX, queueNames []string) ([]*JobCountByQueueAndStateRow, error)

func (*Queries) JobCountByState 

func (q *Queries) JobCountByState(ctx context.Context, db DBTX, state string) (int64, error)

func (*Queries) JobDelete 

func (q *Queries) JobDelete(ctx context.Context, db DBTX, id int64) (*RiverJob, error)

Differs by necessity from other drivers because SQLite doesn't support `DELETE` inside CTEs so we can't delete if running but select otherwise. Instead, the driver uses a transaction to optimisticaly try a delete, but perform a subsequent fetch on a not found to return the right status.

func (*Queries) JobDeleteBefore 

func (q *Queries) JobDeleteBefore(ctx context.Context, db DBTX, arg *JobDeleteBeforeParams) (sql.Result, error)

func (*Queries) JobDeleteMany added in v0.24.0 

func (q *Queries) JobDeleteMany(ctx context.Context, db DBTX, max int64) ([]*RiverJob, error)

func (*Queries) JobGetAvailable 

func (q *Queries) JobGetAvailable(ctx context.Context, db DBTX, arg *JobGetAvailableParams) ([]*RiverJob, error)

Differs from the Postgres version in that we don't have `FOR UPDATE SKIP LOCKED`. It doesn't exist in SQLite, but more aptly, there's only one writer on SQLite at a time, so nothing else has the rows locked.

func (*Queries) JobGetByID 

func (q *Queries) JobGetByID(ctx context.Context, db DBTX, id int64) (*RiverJob, error)

func (*Queries) JobGetByIDMany 

func (q *Queries) JobGetByIDMany(ctx context.Context, db DBTX, id []int64) ([]*RiverJob, error)

func (*Queries) JobGetByKindMany 

func (q *Queries) JobGetByKindMany(ctx context.Context, db DBTX, kind []string) ([]*RiverJob, error)

func (*Queries) JobGetStuck 

func (q *Queries) JobGetStuck(ctx context.Context, db DBTX, arg *JobGetStuckParams) ([]*RiverJob, error)

func (*Queries) JobInsertFast 

func (q *Queries) JobInsertFast(ctx context.Context, db DBTX, arg *JobInsertFastParams) (*RiverJob, error)

func (*Queries) JobInsertFastMany added in v0.40.0 

func (q *Queries) JobInsertFastMany(ctx context.Context, db DBTX, jobs []byte) ([]*RiverJob, error)

func (*Queries) JobInsertFastManyNoReturning added in v0.40.0 

func (q *Queries) JobInsertFastManyNoReturning(ctx context.Context, db DBTX, jobs []byte) (int64, error)

func (*Queries) JobInsertFastNoReturning 

func (q *Queries) JobInsertFastNoReturning(ctx context.Context, db DBTX, arg *JobInsertFastNoReturningParams) (int64, error)

func (*Queries) JobInsertFull 

func (q *Queries) JobInsertFull(ctx context.Context, db DBTX, arg *JobInsertFullParams) (*RiverJob, error)

func (*Queries) JobInsertFullMany added in v0.40.0 

func (q *Queries) JobInsertFullMany(ctx context.Context, db DBTX, jobs []byte) ([]*RiverJob, error)

func (*Queries) JobKindList added in v0.24.0 

func (q *Queries) JobKindList(ctx context.Context, db DBTX, arg *JobKindListParams) ([]string, error)

func (*Queries) JobList 

func (q *Queries) JobList(ctx context.Context, db DBTX, max int64) ([]*RiverJob, error)

func (*Queries) JobRescue 

func (q *Queries) JobRescue(ctx context.Context, db DBTX, arg *JobRescueParams) error

Rescue a job.

This is supposed to rescue jobs in batches, but various limitations of the combined SQLite + sqlc has left me unable to find a way of injecting many arguments en masse (like how we slightly abuse arrays to pull it off for the Postgres drivers), and SQLite doesn't support `UPDATE` in CTEs, so we loop over many insert operations instead, with the expectation that this may be fixable in the future. Because SQLite targets will often be local and with a very minimal round trip compared to a network, looping over operations is probably okay performance-wise.

func (*Queries) JobRetry 

func (q *Queries) JobRetry(ctx context.Context, db DBTX, arg *JobRetryParams) (*RiverJob, error)

Differs by necessity from other drivers because SQLite doesn't support `UPDATE` inside CTEs so we can't retry if running but select otherwise. Instead, the driver uses a transaction to optimisticaly try an update, but perform a subsequent fetch on a not found to return the right status.

I had to invert the last 'AND' expression below (was an 'AND NOT') due to an sqlc bug. Something about sqlc's SQLite parser cannot detect a parameter inside an `AND NOT`. I'll try to get this fixed upstream at some point so we can clean this up and keep it more like the Postgres version.

func (*Queries) JobScheduleGetCollision 

func (q *Queries) JobScheduleGetCollision(ctx context.Context, db DBTX, arg *JobScheduleGetCollisionParams) (*RiverJob, error)

func (*Queries) JobScheduleGetEligible 

func (q *Queries) JobScheduleGetEligible(ctx context.Context, db DBTX, arg *JobScheduleGetEligibleParams) ([]*RiverJob, error)

func (*Queries) JobScheduleSetAvailable 

func (q *Queries) JobScheduleSetAvailable(ctx context.Context, db DBTX, id []int64) ([]*RiverJob, error)

func (*Queries) JobScheduleSetDiscarded 

func (q *Queries) JobScheduleSetDiscarded(ctx context.Context, db DBTX, arg *JobScheduleSetDiscardedParams) ([]*RiverJob, error)

func (*Queries) JobSetMetadataIfNotRunning 

func (q *Queries) JobSetMetadataIfNotRunning(ctx context.Context, db DBTX, arg *JobSetMetadataIfNotRunningParams) (*RiverJob, error)

This doesn't exist under the Postgres driver, but needed as an extra query for JobSetStateIfRunning to use when falling back to non-running jobs.

func (*Queries) JobSetStateIfRunning 

func (q *Queries) JobSetStateIfRunning(ctx context.Context, db DBTX, arg *JobSetStateIfRunningParams) (*RiverJob, error)

Differs significantly from the Postgres version in that it can't do a bulk update, and since sqlc doesn't support `UPDATE` in CTEs, we need separate queries like JobSetMetadataIfNotRunning to do the fallback work.

func (*Queries) JobUpdate 

func (q *Queries) JobUpdate(ctx context.Context, db DBTX, arg *JobUpdateParams) (*RiverJob, error)

func (*Queries) JobUpdateFull added in v0.29.0 

func (q *Queries) JobUpdateFull(ctx context.Context, db DBTX, arg *JobUpdateFullParams) (*RiverJob, error)

A generalized update for any property on a job. This brings in a large number of parameters and therefore may be more suitable for testing than production.

func (*Queries) LeaderAttemptElect 

func (q *Queries) LeaderAttemptElect(ctx context.Context, db DBTX, arg *LeaderAttemptElectParams) (*RiverLeader, error)

func (*Queries) LeaderAttemptReelect 

func (q *Queries) LeaderAttemptReelect(ctx context.Context, db DBTX, arg *LeaderAttemptReelectParams) (*RiverLeader, error)

func (*Queries) LeaderDeleteExpired 

func (q *Queries) LeaderDeleteExpired(ctx context.Context, db DBTX, now *string) (int64, error)

func (*Queries) LeaderGetElectedLeader 

func (q *Queries) LeaderGetElectedLeader(ctx context.Context, db DBTX) (*RiverLeader, error)

func (*Queries) LeaderInsert 

func (q *Queries) LeaderInsert(ctx context.Context, db DBTX, arg *LeaderInsertParams) (*RiverLeader, error)

func (*Queries) LeaderResign 

func (q *Queries) LeaderResign(ctx context.Context, db DBTX, arg *LeaderResignParams) (int64, error)

func (*Queries) NotificationDeleteBefore added in v0.40.0 

func (q *Queries) NotificationDeleteBefore(ctx context.Context, db DBTX, createdAtHorizon string) (int64, error)

func (*Queries) NotificationGetAfter added in v0.40.0 

func (q *Queries) NotificationGetAfter(ctx context.Context, db DBTX, after int64) (*RiverNotification, error)

func (*Queries) NotificationGetLastID added in v0.40.0 

func (q *Queries) NotificationGetLastID(ctx context.Context, db DBTX) (int64, error)

func (*Queries) NotificationInsertMany added in v0.40.0 

func (q *Queries) NotificationInsertMany(ctx context.Context, db DBTX, notifications []byte) error

func (*Queries) QueueCreateOrSetUpdatedAt 

func (q *Queries) QueueCreateOrSetUpdatedAt(ctx context.Context, db DBTX, arg *QueueCreateOrSetUpdatedAtParams) (*RiverQueue, error)

func (*Queries) QueueDeleteExpired 

func (q *Queries) QueueDeleteExpired(ctx context.Context, db DBTX, arg *QueueDeleteExpiredParams) ([]*RiverQueue, error)

func (*Queries) QueueGet 

func (q *Queries) QueueGet(ctx context.Context, db DBTX, name string) (*RiverQueue, error)

func (*Queries) QueueList 

func (q *Queries) QueueList(ctx context.Context, db DBTX, max int64) ([]*RiverQueue, error)

func (*Queries) QueueNameList added in v0.24.0 

func (q *Queries) QueueNameList(ctx context.Context, db DBTX, arg *QueueNameListParams) ([]string, error)

func (*Queries) QueuePause 

func (q *Queries) QueuePause(ctx context.Context, db DBTX, arg *QueuePauseParams) (int64, error)

func (*Queries) QueueResume 

func (q *Queries) QueueResume(ctx context.Context, db DBTX, arg *QueueResumeParams) (int64, error)

func (*Queries) QueueUpdate 

func (q *Queries) QueueUpdate(ctx context.Context, db DBTX, arg *QueueUpdateParams) (*RiverQueue, error)

func (*Queries) RiverMigrationDeleteAssumingMainMany 

func (q *Queries) RiverMigrationDeleteAssumingMainMany(ctx context.Context, db DBTX, version []int64) ([]*RiverMigrationDeleteAssumingMainManyRow, error)

func (*Queries) RiverMigrationDeleteByLineAndVersionMany 

func (q *Queries) RiverMigrationDeleteByLineAndVersionMany(ctx context.Context, db DBTX, arg *RiverMigrationDeleteByLineAndVersionManyParams) ([]*RiverMigration, error)

func (*Queries) RiverMigrationGetAllAssumingMain 

func (q *Queries) RiverMigrationGetAllAssumingMain(ctx context.Context, db DBTX) ([]*RiverMigrationGetAllAssumingMainRow, error)

This is a compatibility query for getting existing migrations before the `line` column was added to the table in version 005. We need to make sure to only select non-line properties so the query doesn't error on older schemas. (Even if we use `SELECT *` below, sqlc materializes it to a list of column names in the generated query.)

func (*Queries) RiverMigrationGetByLine 

func (q *Queries) RiverMigrationGetByLine(ctx context.Context, db DBTX, line string) ([]*RiverMigration, error)

func (*Queries) RiverMigrationInsertMany added in v0.40.0 

func (q *Queries) RiverMigrationInsertMany(ctx context.Context, db DBTX, arg *RiverMigrationInsertManyParams) ([]*RiverMigration, error)

func (*Queries) RiverMigrationInsertManyAssumingMain added in v0.40.0 

func (q *Queries) RiverMigrationInsertManyAssumingMain(ctx context.Context, db DBTX, versions []byte) ([]*RiverMigrationInsertManyAssumingMainRow, error)

func (*Queries) TableExists 

func (q *Queries) TableExists(ctx context.Context, db DBTX, table string) (bool, error)

type QueueCreateOrSetUpdatedAtParams 

type QueueCreateOrSetUpdatedAtParams struct {
	Now       *string
	Metadata  interface{}
	Name      string
	PausedAt  *string
	UpdatedAt *string
}

type QueueDeleteExpiredParams 

type QueueDeleteExpiredParams struct {
	UpdatedAtHorizon time.Time
	Max              int64
}

type QueueNameListParams added in v0.24.0 

type QueueNameListParams struct {
	After   string
	Match   string
	Exclude []string
	Max     int64
}

type QueuePauseParams 

type QueuePauseParams struct {
	Now  *string
	Name string
}

type QueueResumeParams 

type QueueResumeParams struct {
	Now  *string
	Name string
}

type QueueUpdateParams 

type QueueUpdateParams struct {
	MetadataDoUpdate bool
	Metadata         interface{}
	Name             string
}

type RiverJob 

type RiverJob struct {
	ID           int64
	Args         []byte
	Attempt      int64
	AttemptedAt  *time.Time
	AttemptedBy  []byte
	CreatedAt    time.Time
	Errors       []byte
	FinalizedAt  *time.Time
	Kind         string
	MaxAttempts  int64
	Metadata     []byte
	Priority     int64
	Queue        string
	State        string
	ScheduledAt  time.Time
	Tags         []byte
	UniqueKey    []byte
	UniqueStates *int64
}

type RiverLeader 

type RiverLeader struct {
	ElectedAt time.Time
	ExpiresAt time.Time
	LeaderID  string
	Name      string
}

type RiverMigration 

type RiverMigration struct {
	Line      string
	Version   int64
	CreatedAt time.Time
}

type RiverMigrationDeleteAssumingMainManyRow 

type RiverMigrationDeleteAssumingMainManyRow struct {
	CreatedAt time.Time
	Version   int64
}

type RiverMigrationDeleteByLineAndVersionManyParams 

type RiverMigrationDeleteByLineAndVersionManyParams struct {
	Line    string
	Version []int64
}

type RiverMigrationGetAllAssumingMainRow 

type RiverMigrationGetAllAssumingMainRow struct {
	CreatedAt time.Time
	Version   int64
}

type RiverMigrationInsertManyAssumingMainRow added in v0.40.0 

type RiverMigrationInsertManyAssumingMainRow struct {
	CreatedAt time.Time
	Version   int64
}

type RiverMigrationInsertManyParams added in v0.40.0 

type RiverMigrationInsertManyParams struct {
	Line     string
	Versions []byte
}

type RiverNotification added in v0.40.0 

type RiverNotification struct {
	ID        int64
	CreatedAt time.Time
	Payload   string
	Topic     string
}

type RiverQueue 

type RiverQueue struct {
	Name      string
	CreatedAt time.Time
	Metadata  []byte
	PausedAt  *time.Time
	UpdatedAt time.Time
}

type SqliteMaster 

type SqliteMaster struct {
	Type     *string
	Name     *string
	TblName  *string
	Rootpage *int64
	Sql      *string
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.