Engine: Scripting support (#383)

* WIP

* updated appveyor and increased deadline 5 seconds due to increased linters being added

* revert files to upstream/engine

* WIP

* WIP

* mod file changes

* added script manager

* Added manager/and cli interfaces to scripting

* Added script task handler

* WIP - Added timer/repeat support and fleshed out wrapper further

* autoload support added + WIP

* WIP commit

* added account balance info

* btc markets temp work around

* WIP - merged with upstream for new order package BTC Markets responses broken

* Cancel order wrapper WIP

*  order wrapper update

* Added test coverage for VM

* moved to map for VM List shutdown of all VM now handled added gctcli commands for list and stop of running scripts

* added override to load/execute for path

* fixed incorrect channel shutdown added further test coverage and restructured gctcli commands into sub commands

* increased test coverage for packages

* Added docs cleaned up tests and example scripts

* Test coverage increased for module/gct/exchange package

* windows fixes

* merged upstream/engine

* WIP

* logger fixes - removed pointer to bool check removed duplicate test check for logger

* remove unused mutex

* added inital upload support

* fix linter issues for go-fmt

* added zip support for uploading and added base for fund withdrawing

* changed error return types and also log errors, fix zip path issue

* improved error outputs and code flow

* pairs response fix added protobuf defs for stop all and list all

* added stop all running scripts general clean up and moved across to OrderManager

* linter fixes (gofmt)

* added list all command

* rewrote zip handler to be cleaner also fixed file overwrite on upload

* added query command reworked tests

* added further error checking to compileandrun corrected use of pointers for accountinfo

* bumped tengo version

* Removed named returns reworded log messages removed unused falseptr

* WIP

* Added virutal machine limit improved config options

* added model for script event added upload validation

* script_event table has been completed, tests for wrapper functions implemented

* README updates

* reverted changes opened new PR to move withdraw struct outs

* intial work on adding withdraw support after merger of withdraw package

* started work on examples

* Added crypto withdraw support

* fix switch case assignment and gofmt project

* Reworking Fiat withdraw request pending #402

* removed double pointer call

* added withdraw support for fiat  currencies

* added tests for withdraw methods increased readme

* removed local tengo require and also fix linter issues

* Added default log size const added basic test for invalid script execution

* First pass at moving wrapper to validator package to allow proper validation of uploaded scripts

* Added script details to README added config test added test for no file extension

* moved tests to const and fixed incorrect pathing

* added test coverage to withdraw package

* corrected file close handling

* point to included configtest.json

* extended validator support when a script is uploaded

* Bug fix on bool logic

* Added mutex

* Don't create autit events on test execution

* reverted common to master

* moved file rename to unix timestamp format

* converted logger enabled back to pointer as i need nilness check also moved scriptid to text over blob

* started work on autoload add/remove support

* First round of PR fixes (mostly commented exports)

* Moved GCTScript load to last, removed unneeded error from cleanup()

* Comment clairty for AuitEventID

* added autoload add/remove command to cli

* added tests for autoload

* Test updates for Exchanges

* linter fixes (gofmt)

* Removed double check of engine pointer

* remove possible nil pointer on GetSpecificTicker

* Fixed not closing file handler on write that causes archive removal to fail

* file handler Close clean ups

* corrected spelling on error return and return invalid name n autoload

* moved strings to cosnt moved bool pointer creation to convert package

* new zip extractor added

* Validation has been added to archive uploads

* removed shadow var on err

* added ok check to conversion

* converted condition check

* basic test for zip extract added

* new zip handler

* reverted back to old atomic loading system

* removed shadow err

* lets add a new line

* added space to error return

* command line toggle for script now works properly

* readme updated

* set configLoaded to true

* check for configLoaded condition

* added mutex to allow for multiple access on virtual machine increased test coverage disable script manager if scripting is disabled

* linked up to enable/disablesubsystem commands

* added start/stop example to readme

* reworked logic on test as check should be done on Load()

* updated to tengo v2

* linters

* lower time on ntp client to stop slippage

* remove all fails if any fail validtion from an archive

* remove vm from list if timer is invalid

* removed shadow on err

* remove config creation from NTPCheck test

* WIP testing DB changes

* add unique constraint

* WIP: created has many model

* linters run

* basic sqlite3 support added for new database format

* linters run

* Added test coverage for script repo

* removed unused print

* updated env vars for CI instances

* updated env vars for CI instances

* Updated test packages

* Test updates for postgresql

* removed invalid tests from postgres

* remove duplication of struct and improved code flow

* general cleanup

* wording changes on log output

* use databasemgr logger and add support for autoload without file extension

* corrected test naming

* return correct error

* return correct error again version 82

* store scriptdata on creation

* Hello

* Errorln -> Errorf

* Removed unused vars

* Read me updates

* testing without parallel

* comment on exported type

* added nil check against VM for test

* add debugging information

* gofmt

* remove verbose and data sent to channel

* Added debug information

* linter fixes (gofmt)

* remove unused CompileAndRun() call

* test sleep to see if issue is timing related

* semi-concurrent map fixes

* one day i will run gofmt or setup precommit hooks

* new line :D

* increased test coverage

* added correct sleep time

* Moved over to sync map

* linter fixes (gofmt)

* goimports

* moved VM related methods to vm.go

* new line at end of file

* trying increased timeout on golangci-lint for appveyor

* add debugging information

* removed timeout

* reworked timeout logic

* linter fixes (gofmt)

* increased test coverage

* increased test coverage

* one day i will run gofmt or setup precommit hooks

* removed unused exchange test

* increased golangci-lint timeout

* Added nil check on shutdown and test coverage for it lowered timeout back to 1:30

* reworked ID system

* removed script hash as it was unused

* added comments on exported methods and read me update

* reorder code

* removed to atomic.value for test execution flag

* increased test coverage

* move add further up execution

* point to correct script file

database/migrations/20191210124551_enable_pgcrypto/postgres.sql

@@ -0,0 +1,6 @@
+-- +goose Up
+-- SQL in this section is executed when the migration is applied.
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+-- +goose Down
+-- SQL in this section is executed when the migration is rolled back.
+DROP EXTENSION IF EXISTS pgcrypto;

database/migrations/20191210124551_enable_pgcrypto/sqlite3.sql

@@ -0,0 +1,8 @@
+-- +goose Up
+-- +goose StatementBegin
+SELECT 'up SQL query';
+-- +goose StatementEnd
+-- +goose Down
+-- +goose StatementBegin
+SELECT 'down SQL query';
+-- +goose StatementEnd

database/migrations/20191210124558_script/postgres.sql

@@ -0,0 +1,16 @@
+-- +goose Up
+-- SQL in this section is executed when the migration is applied.
+CREATE TABLE IF NOT EXISTS script
+(
+    id uuid   PRIMARY KEY DEFAULT gen_random_uuid(),
+    script_id text not null,
+    script_name varchar not null,
+    script_path varchar not null,
+    script_data bytea null,
+    last_executed_at TIMESTAMP DEFAULT (now() at time zone 'utc'),
+    created_at TIMESTAMP DEFAULT (now() at time zone 'utc'),
+    CONSTRAINT script_event_uniq UNIQUE (script_id)
+);
+-- +goose Down
+-- SQL in this section is executed when the migration is rolled back.
+DROP TABLE script;

database/migrations/20191210124558_script/sqlite3.sql

@@ -0,0 +1,14 @@
+-- +goose Up
+-- SQL in this section is executed when the migration is applied.
+CREATE TABLE "script" (
+    id	        text not null primary key,
+    script_id   text not null,
+    script_name text not null,
+    script_path text not NULL,
+    script_data blob null,
+    last_executed_at timestamp not null default CURRENT_TIMESTAMP,
+    created_at   timestamp not null default CURRENT_TIMESTAMP
+);
+-- +goose Down
+-- SQL in this section is executed when the migration is rolled back.
+DROP TABLE "script";

database/migrations/20200114141913_script_execution/postgres.sql

@@ -0,0 +1,13 @@
+-- +goose Up
+-- SQL in this section is executed when the migration is applied.
+CREATE TABLE IF NOT EXISTS script_execution
+(
+    id uuid          PRIMARY KEY DEFAULT gen_random_uuid(),
+    script_id uuid REFERENCES script(id) ON DELETE CASCADE,
+    execution_type varchar NOT NULL,
+    execution_status varchar NOT NULL,
+    execution_time TIMESTAMP NOT NULL DEFAULT (now() at time zone 'utc')
+);
+-- +goose Down
+-- SQL in this section is executed when the migration is rolled back.
+DROP TABLE script_execution;

database/migrations/20200114141913_script_execution/sqlite3.sql

@@ -0,0 +1,14 @@
+-- +goose Up
+-- SQL in this section is executed when the migration is applied.
+CREATE TABLE IF NOT EXISTS "script_execution"
+(
+    id	        integer not null primary key,
+    script_id text not null,
+    execution_type text NOT NULL,
+    execution_status text NOT NULL,
+    execution_time timestamp not null default CURRENT_TIMESTAMP,
+    FOREIGN KEY(script_id) REFERENCES script(id)
+);
+-- +goose Down
+-- SQL in this section is executed when the migration is rolled back.
+DROP TABLE script_execution;

database/models/postgres/audit_event_test.go

@@ -568,7 +568,7 @@ func testAuditEventsSelect(t *testing.T) {
 }
 
 var (
-	auditEventDBTypes = map[string]string{`ID`: `bigint`, `Type`: `character varying`, `Identifier`: `character varying`, `Message`: `text`, `CreatedAt`: `timestamp with time zone`}
+	auditEventDBTypes = map[string]string{`ID`: `bigint`, `Type`: `character varying`, `Identifier`: `character varying`, `Message`: `text`, `CreatedAt`: `timestamp without time zone`}
 	_                 = bytes.MinRead
 )
 

database/models/postgres/boil_suites_test.go

@@ -13,51 +13,64 @@ import "testing"
 // Separating the tests thusly grants avoidance of Postgres deadlocks.
 func TestParent(t *testing.T) {
 	t.Run("AuditEvents", testAuditEvents)
+	t.Run("Scripts", testScripts)
 }
 
 func TestDelete(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsDelete)
+	t.Run("Scripts", testScriptsDelete)
 }
 
 func TestQueryDeleteAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsQueryDeleteAll)
+	t.Run("Scripts", testScriptsQueryDeleteAll)
 }
 
 func TestSliceDeleteAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSliceDeleteAll)
+	t.Run("Scripts", testScriptsSliceDeleteAll)
 }
 
 func TestExists(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsExists)
+	t.Run("Scripts", testScriptsExists)
 }
 
 func TestFind(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsFind)
+	t.Run("Scripts", testScriptsFind)
 }
 
 func TestBind(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsBind)
+	t.Run("Scripts", testScriptsBind)
 }
 
 func TestOne(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsOne)
+	t.Run("Scripts", testScriptsOne)
 }
 
 func TestAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsAll)
+	t.Run("Scripts", testScriptsAll)
 }
 
 func TestCount(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsCount)
+	t.Run("Scripts", testScriptsCount)
 }
 
 func TestHooks(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsHooks)
+	t.Run("Scripts", testScriptsHooks)
 }
 
 func TestInsert(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsInsert)
 	t.Run("AuditEvents", testAuditEventsInsertWhitelist)
+	t.Run("Scripts", testScriptsInsert)
+	t.Run("Scripts", testScriptsInsertWhitelist)
 }
 
 // TestToOne tests cannot be run in parallel
@@ -102,20 +115,25 @@ func TestToManyRemove(t *testing.T) {}
 
 func TestReload(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsReload)
+	t.Run("Scripts", testScriptsReload)
 }
 
 func TestReloadAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsReloadAll)
+	t.Run("Scripts", testScriptsReloadAll)
 }
 
 func TestSelect(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSelect)
+	t.Run("Scripts", testScriptsSelect)
 }
 
 func TestUpdate(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsUpdate)
+	t.Run("Scripts", testScriptsUpdate)
 }
 
 func TestSliceUpdateAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSliceUpdateAll)
+	t.Run("Scripts", testScriptsSliceUpdateAll)
 }

database/models/postgres/boil_table_names.go

@@ -4,7 +4,11 @@
 package postgres
 
 var TableNames = struct {
-	AuditEvent string
+	AuditEvent      string
+	Script          string
+	ScriptExecution string
 }{
-	AuditEvent: "audit_event",
+	AuditEvent:      "audit_event",
+	Script:          "script",
+	ScriptExecution: "script_execution",
 }

database/models/postgres/psql_suites_test.go

@@ -7,4 +7,5 @@ import "testing"
 
 func TestUpsert(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsUpsert)
+	t.Run("Scripts", testScriptsUpsert)
 }

database/models/postgres/script_execution_test.go

@@ -0,0 +1,892 @@
+// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package postgres
+
+import (
+	"bytes"
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/thrasher-corp/sqlboiler/queries"
+	"github.com/thrasher-corp/sqlboiler/randomize"
+	"github.com/thrasher-corp/sqlboiler/strmangle"
+)
+
+var (
+	// Relationships sometimes use the reflection helper queries.Equal/queries.Assign
+	// so force a package dependency in case they don't.
+	_ = queries.Equal
+)
+
+func testScriptExecutions(t *testing.T) {
+	t.Parallel()
+
+	query := ScriptExecutions()
+
+	if query.Query == nil {
+		t.Error("expected a query, got nothing")
+	}
+}
+
+func testScriptExecutionsDelete(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := o.Delete(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsQueryDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := ScriptExecutions().DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsSliceDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptExecutionSlice{o}
+
+	if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsExists(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	e, err := ScriptExecutionExists(ctx, tx, o.ID)
+	if err != nil {
+		t.Errorf("Unable to check if ScriptExecution exists: %s", err)
+	}
+	if !e {
+		t.Errorf("Expected ScriptExecutionExists to return true, but got false.")
+	}
+}
+
+func testScriptExecutionsFind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	scriptExecutionFound, err := FindScriptExecution(ctx, tx, o.ID)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if scriptExecutionFound == nil {
+		t.Error("want a record, got nil")
+	}
+}
+
+func testScriptExecutionsBind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = ScriptExecutions().Bind(ctx, tx, o); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsOne(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if x, err := ScriptExecutions().One(ctx, tx); err != nil {
+		t.Error(err)
+	} else if x == nil {
+		t.Error("expected to get a non nil record")
+	}
+}
+
+func testScriptExecutionsAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	scriptExecutionOne := &ScriptExecution{}
+	scriptExecutionTwo := &ScriptExecution{}
+	if err = randomize.Struct(seed, scriptExecutionOne, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptExecutionTwo, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptExecutionOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptExecutionTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := ScriptExecutions().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 2 {
+		t.Error("want 2 records, got:", len(slice))
+	}
+}
+
+func testScriptExecutionsCount(t *testing.T) {
+	t.Parallel()
+
+	var err error
+	seed := randomize.NewSeed()
+	scriptExecutionOne := &ScriptExecution{}
+	scriptExecutionTwo := &ScriptExecution{}
+	if err = randomize.Struct(seed, scriptExecutionOne, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptExecutionTwo, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptExecutionOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptExecutionTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 2 {
+		t.Error("want 2 records, got:", count)
+	}
+}
+
+func scriptExecutionBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func testScriptExecutionsHooks(t *testing.T) {
+	t.Parallel()
+
+	var err error
+
+	ctx := context.Background()
+	empty := &ScriptExecution{}
+	o := &ScriptExecution{}
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, false); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution object: %s", err)
+	}
+
+	AddScriptExecutionHook(boil.BeforeInsertHook, scriptExecutionBeforeInsertHook)
+	if err = o.doBeforeInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeInsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterInsertHook, scriptExecutionAfterInsertHook)
+	if err = o.doAfterInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterInsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterSelectHook, scriptExecutionAfterSelectHook)
+	if err = o.doAfterSelectHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterSelectHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterSelectHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeUpdateHook, scriptExecutionBeforeUpdateHook)
+	if err = o.doBeforeUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeUpdateHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterUpdateHook, scriptExecutionAfterUpdateHook)
+	if err = o.doAfterUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterUpdateHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeDeleteHook, scriptExecutionBeforeDeleteHook)
+	if err = o.doBeforeDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeDeleteHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterDeleteHook, scriptExecutionAfterDeleteHook)
+	if err = o.doAfterDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterDeleteHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeUpsertHook, scriptExecutionBeforeUpsertHook)
+	if err = o.doBeforeUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeUpsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterUpsertHook, scriptExecutionAfterUpsertHook)
+	if err = o.doAfterUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterUpsertHooks = []ScriptExecutionHook{}
+}
+
+func testScriptExecutionsInsert(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptExecutionsInsertWhitelist(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Whitelist(scriptExecutionColumnsWithoutDefault...)); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptExecutionToOneScriptUsingScript(t *testing.T) {
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var local ScriptExecution
+	var foreign Script
+
+	seed := randomize.NewSeed()
+	if err := randomize.Struct(seed, &local, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err := randomize.Struct(seed, &foreign, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	queries.Assign(&local.ScriptID, foreign.ID)
+	if err := local.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	check, err := local.Script().One(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !queries.Equal(check.ID, foreign.ID) {
+		t.Errorf("want: %v, got %v", foreign.ID, check.ID)
+	}
+
+	slice := ScriptExecutionSlice{&local}
+	if err = local.L.LoadScript(ctx, tx, false, (*[]*ScriptExecution)(&slice), nil); err != nil {
+		t.Fatal(err)
+	}
+	if local.R.Script == nil {
+		t.Error("struct should have been eager loaded")
+	}
+
+	local.R.Script = nil
+	if err = local.L.LoadScript(ctx, tx, true, &local, nil); err != nil {
+		t.Fatal(err)
+	}
+	if local.R.Script == nil {
+		t.Error("struct should have been eager loaded")
+	}
+}
+
+func testScriptExecutionToOneSetOpScriptUsingScript(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a ScriptExecution
+	var b, c Script
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, scriptExecutionDBTypes, false, strmangle.SetComplement(scriptExecutionPrimaryKeyColumns, scriptExecutionColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &b, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &c, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	for i, x := range []*Script{&b, &c} {
+		err = a.SetScript(ctx, tx, i != 0, x)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if a.R.Script != x {
+			t.Error("relationship struct not set to correct value")
+		}
+
+		if x.R.ScriptExecutions[0] != &a {
+			t.Error("failed to append to foreign relationship struct")
+		}
+		if !queries.Equal(a.ScriptID, x.ID) {
+			t.Error("foreign key was wrong value", a.ScriptID)
+		}
+
+		zero := reflect.Zero(reflect.TypeOf(a.ScriptID))
+		reflect.Indirect(reflect.ValueOf(&a.ScriptID)).Set(zero)
+
+		if err = a.Reload(ctx, tx); err != nil {
+			t.Fatal("failed to reload", err)
+		}
+
+		if !queries.Equal(a.ScriptID, x.ID) {
+			t.Error("foreign key was wrong value", a.ScriptID, x.ID)
+		}
+	}
+}
+
+func testScriptExecutionToOneRemoveOpScriptUsingScript(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a ScriptExecution
+	var b Script
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, scriptExecutionDBTypes, false, strmangle.SetComplement(scriptExecutionPrimaryKeyColumns, scriptExecutionColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &b, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = a.SetScript(ctx, tx, true, &b); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = a.RemoveScript(ctx, tx, &b); err != nil {
+		t.Error("failed to remove relationship")
+	}
+
+	count, err := a.Script().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+	if count != 0 {
+		t.Error("want no relationships remaining")
+	}
+
+	if a.R.Script != nil {
+		t.Error("R struct entry should be nil")
+	}
+
+	if !queries.IsValuerNil(a.ScriptID) {
+		t.Error("foreign key value should be nil")
+	}
+
+	if len(b.R.ScriptExecutions) != 0 {
+		t.Error("failed to remove a from b's relationships")
+	}
+}
+
+func testScriptExecutionsReload(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = o.Reload(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsReloadAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptExecutionSlice{o}
+
+	if err = slice.ReloadAll(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsSelect(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := ScriptExecutions().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 1 {
+		t.Error("want one record, got:", len(slice))
+	}
+}
+
+var (
+	scriptExecutionDBTypes = map[string]string{`ID`: `uuid`, `ScriptID`: `uuid`, `ExecutionType`: `character varying`, `ExecutionStatus`: `character varying`, `ExecutionTime`: `timestamp without time zone`}
+	_                      = bytes.MinRead
+)
+
+func testScriptExecutionsUpdate(t *testing.T) {
+	t.Parallel()
+
+	if 0 == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with no primary key columns")
+	}
+	if len(scriptExecutionAllColumns) == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only affect one row but affected", rowsAff)
+	}
+}
+
+func testScriptExecutionsSliceUpdateAll(t *testing.T) {
+	t.Parallel()
+
+	if len(scriptExecutionAllColumns) == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	// Remove Primary keys and unique columns from what we plan to update
+	var fields []string
+	if strmangle.StringSliceMatch(scriptExecutionAllColumns, scriptExecutionPrimaryKeyColumns) {
+		fields = scriptExecutionAllColumns
+	} else {
+		fields = strmangle.SetComplement(
+			scriptExecutionAllColumns,
+			scriptExecutionPrimaryKeyColumns,
+		)
+	}
+
+	value := reflect.Indirect(reflect.ValueOf(o))
+	typ := reflect.TypeOf(o).Elem()
+	n := typ.NumField()
+
+	updateMap := M{}
+	for _, col := range fields {
+		for i := 0; i < n; i++ {
+			f := typ.Field(i)
+			if f.Tag.Get("boil") == col {
+				updateMap[col] = value.Field(i).Interface()
+			}
+		}
+	}
+
+	slice := ScriptExecutionSlice{o}
+	if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("wanted one record updated but got", rowsAff)
+	}
+}
+
+func testScriptExecutionsUpsert(t *testing.T) {
+	t.Parallel()
+
+	if len(scriptExecutionAllColumns) == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	// Attempt the INSERT side of an UPSERT
+	o := ScriptExecution{}
+	if err = randomize.Struct(seed, &o, scriptExecutionDBTypes, true); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil {
+		t.Errorf("Unable to upsert ScriptExecution: %s", err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	// Attempt the UPDATE side of an UPSERT
+	if err = randomize.Struct(seed, &o, scriptExecutionDBTypes, false, scriptExecutionPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil {
+		t.Errorf("Unable to upsert ScriptExecution: %s", err)
+	}
+
+	count, err = ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}

database/models/sqlite3/boil_suites_test.go

@@ -13,56 +13,84 @@ import "testing"
 // Separating the tests thusly grants avoidance of Postgres deadlocks.
 func TestParent(t *testing.T) {
 	t.Run("AuditEvents", testAuditEvents)
+	t.Run("Scripts", testScripts)
+	t.Run("ScriptExecutions", testScriptExecutions)
 }
 
 func TestDelete(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsDelete)
+	t.Run("Scripts", testScriptsDelete)
+	t.Run("ScriptExecutions", testScriptExecutionsDelete)
 }
 
 func TestQueryDeleteAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsQueryDeleteAll)
+	t.Run("Scripts", testScriptsQueryDeleteAll)
+	t.Run("ScriptExecutions", testScriptExecutionsQueryDeleteAll)
 }
 
 func TestSliceDeleteAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSliceDeleteAll)
+	t.Run("Scripts", testScriptsSliceDeleteAll)
+	t.Run("ScriptExecutions", testScriptExecutionsSliceDeleteAll)
 }
 
 func TestExists(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsExists)
+	t.Run("Scripts", testScriptsExists)
+	t.Run("ScriptExecutions", testScriptExecutionsExists)
 }
 
 func TestFind(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsFind)
+	t.Run("Scripts", testScriptsFind)
+	t.Run("ScriptExecutions", testScriptExecutionsFind)
 }
 
 func TestBind(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsBind)
+	t.Run("Scripts", testScriptsBind)
+	t.Run("ScriptExecutions", testScriptExecutionsBind)
 }
 
 func TestOne(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsOne)
+	t.Run("Scripts", testScriptsOne)
+	t.Run("ScriptExecutions", testScriptExecutionsOne)
 }
 
 func TestAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsAll)
+	t.Run("Scripts", testScriptsAll)
+	t.Run("ScriptExecutions", testScriptExecutionsAll)
 }
 
 func TestCount(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsCount)
+	t.Run("Scripts", testScriptsCount)
+	t.Run("ScriptExecutions", testScriptExecutionsCount)
 }
 
 func TestHooks(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsHooks)
+	t.Run("Scripts", testScriptsHooks)
+	t.Run("ScriptExecutions", testScriptExecutionsHooks)
 }
 
 func TestInsert(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsInsert)
 	t.Run("AuditEvents", testAuditEventsInsertWhitelist)
+	t.Run("Scripts", testScriptsInsert)
+	t.Run("Scripts", testScriptsInsertWhitelist)
+	t.Run("ScriptExecutions", testScriptExecutionsInsert)
+	t.Run("ScriptExecutions", testScriptExecutionsInsertWhitelist)
 }
 
 // TestToOne tests cannot be run in parallel
 // or deadlocks can occur.
-func TestToOne(t *testing.T) {}
+func TestToOne(t *testing.T) {
+	t.Run("ScriptExecutionToScriptUsingScript", testScriptExecutionToOneScriptUsingScript)
+}
 
 // TestOneToOne tests cannot be run in parallel
 // or deadlocks can occur.
@@ -70,11 +98,15 @@ func TestOneToOne(t *testing.T) {}
 
 // TestToMany tests cannot be run in parallel
 // or deadlocks can occur.
-func TestToMany(t *testing.T) {}
+func TestToMany(t *testing.T) {
+	t.Run("ScriptToScriptExecutions", testScriptToManyScriptExecutions)
+}
 
 // TestToOneSet tests cannot be run in parallel
 // or deadlocks can occur.
-func TestToOneSet(t *testing.T) {}
+func TestToOneSet(t *testing.T) {
+	t.Run("ScriptExecutionToScriptUsingScriptExecutions", testScriptExecutionToOneSetOpScriptUsingScript)
+}
 
 // TestToOneRemove tests cannot be run in parallel
 // or deadlocks can occur.
@@ -90,7 +122,9 @@ func TestOneToOneRemove(t *testing.T) {}
 
 // TestToManyAdd tests cannot be run in parallel
 // or deadlocks can occur.
-func TestToManyAdd(t *testing.T) {}
+func TestToManyAdd(t *testing.T) {
+	t.Run("ScriptToScriptExecutions", testScriptToManyAddOpScriptExecutions)
+}
 
 // TestToManySet tests cannot be run in parallel
 // or deadlocks can occur.
@@ -102,20 +136,30 @@ func TestToManyRemove(t *testing.T) {}
 
 func TestReload(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsReload)
+	t.Run("Scripts", testScriptsReload)
+	t.Run("ScriptExecutions", testScriptExecutionsReload)
 }
 
 func TestReloadAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsReloadAll)
+	t.Run("Scripts", testScriptsReloadAll)
+	t.Run("ScriptExecutions", testScriptExecutionsReloadAll)
 }
 
 func TestSelect(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSelect)
+	t.Run("Scripts", testScriptsSelect)
+	t.Run("ScriptExecutions", testScriptExecutionsSelect)
 }
 
 func TestUpdate(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsUpdate)
+	t.Run("Scripts", testScriptsUpdate)
+	t.Run("ScriptExecutions", testScriptExecutionsUpdate)
 }
 
 func TestSliceUpdateAll(t *testing.T) {
 	t.Run("AuditEvents", testAuditEventsSliceUpdateAll)
+	t.Run("Scripts", testScriptsSliceUpdateAll)
+	t.Run("ScriptExecutions", testScriptExecutionsSliceUpdateAll)
 }

database/models/sqlite3/boil_table_names.go

@@ -4,7 +4,11 @@
 package sqlite3
 
 var TableNames = struct {
-	AuditEvent string
+	AuditEvent      string
+	Script          string
+	ScriptExecution string
 }{
-	AuditEvent: "audit_event",
+	AuditEvent:      "audit_event",
+	Script:          "script",
+	ScriptExecution: "script_execution",
 }

database/models/sqlite3/script.go

@@ -0,0 +1,987 @@
+// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package sqlite3
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/thrasher-corp/sqlboiler/queries"
+	"github.com/thrasher-corp/sqlboiler/queries/qm"
+	"github.com/thrasher-corp/sqlboiler/queries/qmhelper"
+	"github.com/thrasher-corp/sqlboiler/strmangle"
+	"github.com/volatiletech/null"
+)
+
+// Script is an object representing the database table.
+type Script struct {
+	ID             string     `boil:"id" json:"id" toml:"id" yaml:"id"`
+	ScriptID       string     `boil:"script_id" json:"script_id" toml:"script_id" yaml:"script_id"`
+	ScriptName     string     `boil:"script_name" json:"script_name" toml:"script_name" yaml:"script_name"`
+	ScriptPath     string     `boil:"script_path" json:"script_path" toml:"script_path" yaml:"script_path"`
+	ScriptData     null.Bytes `boil:"script_data" json:"script_data,omitempty" toml:"script_data" yaml:"script_data,omitempty"`
+	LastExecutedAt string     `boil:"last_executed_at" json:"last_executed_at" toml:"last_executed_at" yaml:"last_executed_at"`
+	CreatedAt      string     `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
+
+	R *scriptR `boil:"-" json:"-" toml:"-" yaml:"-"`
+	L scriptL  `boil:"-" json:"-" toml:"-" yaml:"-"`
+}
+
+var ScriptColumns = struct {
+	ID             string
+	ScriptID       string
+	ScriptName     string
+	ScriptPath     string
+	ScriptData     string
+	LastExecutedAt string
+	CreatedAt      string
+}{
+	ID:             "id",
+	ScriptID:       "script_id",
+	ScriptName:     "script_name",
+	ScriptPath:     "script_path",
+	ScriptData:     "script_data",
+	LastExecutedAt: "last_executed_at",
+	CreatedAt:      "created_at",
+}
+
+// Generated where
+
+type whereHelpernull_Bytes struct{ field string }
+
+func (w whereHelpernull_Bytes) EQ(x null.Bytes) qm.QueryMod {
+	return qmhelper.WhereNullEQ(w.field, false, x)
+}
+func (w whereHelpernull_Bytes) NEQ(x null.Bytes) qm.QueryMod {
+	return qmhelper.WhereNullEQ(w.field, true, x)
+}
+func (w whereHelpernull_Bytes) IsNull() qm.QueryMod    { return qmhelper.WhereIsNull(w.field) }
+func (w whereHelpernull_Bytes) IsNotNull() qm.QueryMod { return qmhelper.WhereIsNotNull(w.field) }
+func (w whereHelpernull_Bytes) LT(x null.Bytes) qm.QueryMod {
+	return qmhelper.Where(w.field, qmhelper.LT, x)
+}
+func (w whereHelpernull_Bytes) LTE(x null.Bytes) qm.QueryMod {
+	return qmhelper.Where(w.field, qmhelper.LTE, x)
+}
+func (w whereHelpernull_Bytes) GT(x null.Bytes) qm.QueryMod {
+	return qmhelper.Where(w.field, qmhelper.GT, x)
+}
+func (w whereHelpernull_Bytes) GTE(x null.Bytes) qm.QueryMod {
+	return qmhelper.Where(w.field, qmhelper.GTE, x)
+}
+
+var ScriptWhere = struct {
+	ID             whereHelperstring
+	ScriptID       whereHelperstring
+	ScriptName     whereHelperstring
+	ScriptPath     whereHelperstring
+	ScriptData     whereHelpernull_Bytes
+	LastExecutedAt whereHelperstring
+	CreatedAt      whereHelperstring
+}{
+	ID:             whereHelperstring{field: "\"script\".\"id\""},
+	ScriptID:       whereHelperstring{field: "\"script\".\"script_id\""},
+	ScriptName:     whereHelperstring{field: "\"script\".\"script_name\""},
+	ScriptPath:     whereHelperstring{field: "\"script\".\"script_path\""},
+	ScriptData:     whereHelpernull_Bytes{field: "\"script\".\"script_data\""},
+	LastExecutedAt: whereHelperstring{field: "\"script\".\"last_executed_at\""},
+	CreatedAt:      whereHelperstring{field: "\"script\".\"created_at\""},
+}
+
+// ScriptRels is where relationship names are stored.
+var ScriptRels = struct {
+	ScriptExecutions string
+}{
+	ScriptExecutions: "ScriptExecutions",
+}
+
+// scriptR is where relationships are stored.
+type scriptR struct {
+	ScriptExecutions ScriptExecutionSlice
+}
+
+// NewStruct creates a new relationship struct
+func (*scriptR) NewStruct() *scriptR {
+	return &scriptR{}
+}
+
+// scriptL is where Load methods for each relationship are stored.
+type scriptL struct{}
+
+var (
+	scriptAllColumns            = []string{"id", "script_id", "script_name", "script_path", "script_data", "last_executed_at", "created_at"}
+	scriptColumnsWithoutDefault = []string{"id", "script_id", "script_name", "script_path", "script_data"}
+	scriptColumnsWithDefault    = []string{"last_executed_at", "created_at"}
+	scriptPrimaryKeyColumns     = []string{"id"}
+)
+
+type (
+	// ScriptSlice is an alias for a slice of pointers to Script.
+	// This should generally be used opposed to []Script.
+	ScriptSlice []*Script
+	// ScriptHook is the signature for custom Script hook methods
+	ScriptHook func(context.Context, boil.ContextExecutor, *Script) error
+
+	scriptQuery struct {
+		*queries.Query
+	}
+)
+
+// Cache for insert, update and upsert
+var (
+	scriptType                 = reflect.TypeOf(&Script{})
+	scriptMapping              = queries.MakeStructMapping(scriptType)
+	scriptPrimaryKeyMapping, _ = queries.BindMapping(scriptType, scriptMapping, scriptPrimaryKeyColumns)
+	scriptInsertCacheMut       sync.RWMutex
+	scriptInsertCache          = make(map[string]insertCache)
+	scriptUpdateCacheMut       sync.RWMutex
+	scriptUpdateCache          = make(map[string]updateCache)
+	scriptUpsertCacheMut       sync.RWMutex
+	scriptUpsertCache          = make(map[string]insertCache)
+)
+
+var (
+	// Force time package dependency for automated UpdatedAt/CreatedAt.
+	_ = time.Second
+	// Force qmhelper dependency for where clause generation (which doesn't
+	// always happen)
+	_ = qmhelper.Where
+)
+
+var scriptBeforeInsertHooks []ScriptHook
+var scriptBeforeUpdateHooks []ScriptHook
+var scriptBeforeDeleteHooks []ScriptHook
+var scriptBeforeUpsertHooks []ScriptHook
+
+var scriptAfterInsertHooks []ScriptHook
+var scriptAfterSelectHooks []ScriptHook
+var scriptAfterUpdateHooks []ScriptHook
+var scriptAfterDeleteHooks []ScriptHook
+var scriptAfterUpsertHooks []ScriptHook
+
+// doBeforeInsertHooks executes all "before insert" hooks.
+func (o *Script) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptBeforeInsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeUpdateHooks executes all "before Update" hooks.
+func (o *Script) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptBeforeUpdateHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeDeleteHooks executes all "before Delete" hooks.
+func (o *Script) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptBeforeDeleteHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeUpsertHooks executes all "before Upsert" hooks.
+func (o *Script) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptBeforeUpsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterInsertHooks executes all "after Insert" hooks.
+func (o *Script) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptAfterInsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterSelectHooks executes all "after Select" hooks.
+func (o *Script) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptAfterSelectHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterUpdateHooks executes all "after Update" hooks.
+func (o *Script) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptAfterUpdateHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterDeleteHooks executes all "after Delete" hooks.
+func (o *Script) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptAfterDeleteHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterUpsertHooks executes all "after Upsert" hooks.
+func (o *Script) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptAfterUpsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// AddScriptHook registers your hook function for all future operations.
+func AddScriptHook(hookPoint boil.HookPoint, scriptHook ScriptHook) {
+	switch hookPoint {
+	case boil.BeforeInsertHook:
+		scriptBeforeInsertHooks = append(scriptBeforeInsertHooks, scriptHook)
+	case boil.BeforeUpdateHook:
+		scriptBeforeUpdateHooks = append(scriptBeforeUpdateHooks, scriptHook)
+	case boil.BeforeDeleteHook:
+		scriptBeforeDeleteHooks = append(scriptBeforeDeleteHooks, scriptHook)
+	case boil.BeforeUpsertHook:
+		scriptBeforeUpsertHooks = append(scriptBeforeUpsertHooks, scriptHook)
+	case boil.AfterInsertHook:
+		scriptAfterInsertHooks = append(scriptAfterInsertHooks, scriptHook)
+	case boil.AfterSelectHook:
+		scriptAfterSelectHooks = append(scriptAfterSelectHooks, scriptHook)
+	case boil.AfterUpdateHook:
+		scriptAfterUpdateHooks = append(scriptAfterUpdateHooks, scriptHook)
+	case boil.AfterDeleteHook:
+		scriptAfterDeleteHooks = append(scriptAfterDeleteHooks, scriptHook)
+	case boil.AfterUpsertHook:
+		scriptAfterUpsertHooks = append(scriptAfterUpsertHooks, scriptHook)
+	}
+}
+
+// One returns a single script record from the query.
+func (q scriptQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Script, error) {
+	o := &Script{}
+
+	queries.SetLimit(q.Query, 1)
+
+	err := q.Bind(ctx, exec, o)
+	if err != nil {
+		if errors.Cause(err) == sql.ErrNoRows {
+			return nil, sql.ErrNoRows
+		}
+		return nil, errors.Wrap(err, "sqlite3: failed to execute a one query for script")
+	}
+
+	if err := o.doAfterSelectHooks(ctx, exec); err != nil {
+		return o, err
+	}
+
+	return o, nil
+}
+
+// All returns all Script records from the query.
+func (q scriptQuery) All(ctx context.Context, exec boil.ContextExecutor) (ScriptSlice, error) {
+	var o []*Script
+
+	err := q.Bind(ctx, exec, &o)
+	if err != nil {
+		return nil, errors.Wrap(err, "sqlite3: failed to assign all query results to Script slice")
+	}
+
+	if len(scriptAfterSelectHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doAfterSelectHooks(ctx, exec); err != nil {
+				return o, err
+			}
+		}
+	}
+
+	return o, nil
+}
+
+// Count returns the count of all Script records in the query.
+func (q scriptQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	var count int64
+
+	queries.SetSelect(q.Query, nil)
+	queries.SetCount(q.Query)
+
+	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to count script rows")
+	}
+
+	return count, nil
+}
+
+// Exists checks if the row exists in the table.
+func (q scriptQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
+	var count int64
+
+	queries.SetSelect(q.Query, nil)
+	queries.SetCount(q.Query)
+	queries.SetLimit(q.Query, 1)
+
+	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+	if err != nil {
+		return false, errors.Wrap(err, "sqlite3: failed to check if script exists")
+	}
+
+	return count > 0, nil
+}
+
+// ScriptExecutions retrieves all the script_execution's ScriptExecutions with an executor.
+func (o *Script) ScriptExecutions(mods ...qm.QueryMod) scriptExecutionQuery {
+	var queryMods []qm.QueryMod
+	if len(mods) != 0 {
+		queryMods = append(queryMods, mods...)
+	}
+
+	queryMods = append(queryMods,
+		qm.Where("\"script_execution\".\"script_id\"=?", o.ID),
+	)
+
+	query := ScriptExecutions(queryMods...)
+	queries.SetFrom(query.Query, "\"script_execution\"")
+
+	if len(queries.GetSelect(query.Query)) == 0 {
+		queries.SetSelect(query.Query, []string{"\"script_execution\".*"})
+	}
+
+	return query
+}
+
+// LoadScriptExecutions allows an eager lookup of values, cached into the
+// loaded structs of the objects. This is for a 1-M or N-M relationship.
+func (scriptL) LoadScriptExecutions(ctx context.Context, e boil.ContextExecutor, singular bool, maybeScript interface{}, mods queries.Applicator) error {
+	var slice []*Script
+	var object *Script
+
+	if singular {
+		object = maybeScript.(*Script)
+	} else {
+		slice = *maybeScript.(*[]*Script)
+	}
+
+	args := make([]interface{}, 0, 1)
+	if singular {
+		if object.R == nil {
+			object.R = &scriptR{}
+		}
+		args = append(args, object.ID)
+	} else {
+	Outer:
+		for _, obj := range slice {
+			if obj.R == nil {
+				obj.R = &scriptR{}
+			}
+
+			for _, a := range args {
+				if a == obj.ID {
+					continue Outer
+				}
+			}
+
+			args = append(args, obj.ID)
+		}
+	}
+
+	if len(args) == 0 {
+		return nil
+	}
+
+	query := NewQuery(qm.From(`script_execution`), qm.WhereIn(`script_execution.script_id in ?`, args...))
+	if mods != nil {
+		mods.Apply(query)
+	}
+
+	results, err := query.QueryContext(ctx, e)
+	if err != nil {
+		return errors.Wrap(err, "failed to eager load script_execution")
+	}
+
+	var resultSlice []*ScriptExecution
+	if err = queries.Bind(results, &resultSlice); err != nil {
+		return errors.Wrap(err, "failed to bind eager loaded slice script_execution")
+	}
+
+	if err = results.Close(); err != nil {
+		return errors.Wrap(err, "failed to close results in eager load on script_execution")
+	}
+	if err = results.Err(); err != nil {
+		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for script_execution")
+	}
+
+	if len(scriptExecutionAfterSelectHooks) != 0 {
+		for _, obj := range resultSlice {
+			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
+				return err
+			}
+		}
+	}
+	if singular {
+		object.R.ScriptExecutions = resultSlice
+		for _, foreign := range resultSlice {
+			if foreign.R == nil {
+				foreign.R = &scriptExecutionR{}
+			}
+			foreign.R.Script = object
+		}
+		return nil
+	}
+
+	for _, foreign := range resultSlice {
+		for _, local := range slice {
+			if local.ID == foreign.ScriptID {
+				local.R.ScriptExecutions = append(local.R.ScriptExecutions, foreign)
+				if foreign.R == nil {
+					foreign.R = &scriptExecutionR{}
+				}
+				foreign.R.Script = local
+				break
+			}
+		}
+	}
+
+	return nil
+}
+
+// AddScriptExecutions adds the given related objects to the existing relationships
+// of the script, optionally inserting them as new records.
+// Appends related to o.R.ScriptExecutions.
+// Sets related.R.Script appropriately.
+func (o *Script) AddScriptExecutions(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ScriptExecution) error {
+	var err error
+	for _, rel := range related {
+		if insert {
+			rel.ScriptID = o.ID
+			if err = rel.Insert(ctx, exec, boil.Infer()); err != nil {
+				return errors.Wrap(err, "failed to insert into foreign table")
+			}
+		} else {
+			updateQuery := fmt.Sprintf(
+				"UPDATE \"script_execution\" SET %s WHERE %s",
+				strmangle.SetParamNames("\"", "\"", 0, []string{"script_id"}),
+				strmangle.WhereClause("\"", "\"", 0, scriptExecutionPrimaryKeyColumns),
+			)
+			values := []interface{}{o.ID, rel.ID}
+
+			if boil.DebugMode {
+				fmt.Fprintln(boil.DebugWriter, updateQuery)
+				fmt.Fprintln(boil.DebugWriter, values)
+			}
+
+			if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil {
+				return errors.Wrap(err, "failed to update foreign table")
+			}
+
+			rel.ScriptID = o.ID
+		}
+	}
+
+	if o.R == nil {
+		o.R = &scriptR{
+			ScriptExecutions: related,
+		}
+	} else {
+		o.R.ScriptExecutions = append(o.R.ScriptExecutions, related...)
+	}
+
+	for _, rel := range related {
+		if rel.R == nil {
+			rel.R = &scriptExecutionR{
+				Script: o,
+			}
+		} else {
+			rel.R.Script = o
+		}
+	}
+	return nil
+}
+
+// Scripts retrieves all the records using an executor.
+func Scripts(mods ...qm.QueryMod) scriptQuery {
+	mods = append(mods, qm.From("\"script\""))
+	return scriptQuery{NewQuery(mods...)}
+}
+
+// FindScript retrieves a single record by ID with an executor.
+// If selectCols is empty Find will return all columns.
+func FindScript(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*Script, error) {
+	scriptObj := &Script{}
+
+	sel := "*"
+	if len(selectCols) > 0 {
+		sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
+	}
+	query := fmt.Sprintf(
+		"select %s from \"script\" where \"id\"=?", sel,
+	)
+
+	q := queries.Raw(query, iD)
+
+	err := q.Bind(ctx, exec, scriptObj)
+	if err != nil {
+		if errors.Cause(err) == sql.ErrNoRows {
+			return nil, sql.ErrNoRows
+		}
+		return nil, errors.Wrap(err, "sqlite3: unable to select from script")
+	}
+
+	return scriptObj, nil
+}
+
+// Insert a single record using an executor.
+// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
+func (o *Script) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
+	if o == nil {
+		return errors.New("sqlite3: no script provided for insertion")
+	}
+
+	var err error
+
+	if err := o.doBeforeInsertHooks(ctx, exec); err != nil {
+		return err
+	}
+
+	nzDefaults := queries.NonZeroDefaultSet(scriptColumnsWithDefault, o)
+
+	key := makeCacheKey(columns, nzDefaults)
+	scriptInsertCacheMut.RLock()
+	cache, cached := scriptInsertCache[key]
+	scriptInsertCacheMut.RUnlock()
+
+	if !cached {
+		wl, returnColumns := columns.InsertColumnSet(
+			scriptAllColumns,
+			scriptColumnsWithDefault,
+			scriptColumnsWithoutDefault,
+			nzDefaults,
+		)
+
+		cache.valueMapping, err = queries.BindMapping(scriptType, scriptMapping, wl)
+		if err != nil {
+			return err
+		}
+		cache.retMapping, err = queries.BindMapping(scriptType, scriptMapping, returnColumns)
+		if err != nil {
+			return err
+		}
+		if len(wl) != 0 {
+			cache.query = fmt.Sprintf("INSERT INTO \"script\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
+		} else {
+			cache.query = "INSERT INTO \"script\" () VALUES ()%s%s"
+		}
+
+		var queryOutput, queryReturning string
+
+		if len(cache.retMapping) != 0 {
+			cache.retQuery = fmt.Sprintf("SELECT \"%s\" FROM \"script\" WHERE %s", strings.Join(returnColumns, "\",\""), strmangle.WhereClause("\"", "\"", 0, scriptPrimaryKeyColumns))
+		}
+
+		cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning)
+	}
+
+	value := reflect.Indirect(reflect.ValueOf(o))
+	vals := queries.ValuesFromMapping(value, cache.valueMapping)
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.query)
+		fmt.Fprintln(boil.DebugWriter, vals)
+	}
+
+	_, err = exec.ExecContext(ctx, cache.query, vals...)
+
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to insert into script")
+	}
+
+	var identifierCols []interface{}
+
+	if len(cache.retMapping) == 0 {
+		goto CacheNoHooks
+	}
+
+	identifierCols = []interface{}{
+		o.ID,
+	}
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.retQuery)
+		fmt.Fprintln(boil.DebugWriter, identifierCols...)
+	}
+
+	err = exec.QueryRowContext(ctx, cache.retQuery, identifierCols...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to populate default values for script")
+	}
+
+CacheNoHooks:
+	if !cached {
+		scriptInsertCacheMut.Lock()
+		scriptInsertCache[key] = cache
+		scriptInsertCacheMut.Unlock()
+	}
+
+	return o.doAfterInsertHooks(ctx, exec)
+}
+
+// Update uses an executor to update the Script.
+// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates.
+// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.
+func (o *Script) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
+	var err error
+	if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+	key := makeCacheKey(columns, nil)
+	scriptUpdateCacheMut.RLock()
+	cache, cached := scriptUpdateCache[key]
+	scriptUpdateCacheMut.RUnlock()
+
+	if !cached {
+		wl := columns.UpdateColumnSet(
+			scriptAllColumns,
+			scriptPrimaryKeyColumns,
+		)
+
+		if len(wl) == 0 {
+			return 0, errors.New("sqlite3: unable to update script, could not build whitelist")
+		}
+
+		cache.query = fmt.Sprintf("UPDATE \"script\" SET %s WHERE %s",
+			strmangle.SetParamNames("\"", "\"", 0, wl),
+			strmangle.WhereClause("\"", "\"", 0, scriptPrimaryKeyColumns),
+		)
+		cache.valueMapping, err = queries.BindMapping(scriptType, scriptMapping, append(wl, scriptPrimaryKeyColumns...))
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping)
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.query)
+		fmt.Fprintln(boil.DebugWriter, values)
+	}
+
+	var result sql.Result
+	result, err = exec.ExecContext(ctx, cache.query, values...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update script row")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by update for script")
+	}
+
+	if !cached {
+		scriptUpdateCacheMut.Lock()
+		scriptUpdateCache[key] = cache
+		scriptUpdateCacheMut.Unlock()
+	}
+
+	return rowsAff, o.doAfterUpdateHooks(ctx, exec)
+}
+
+// UpdateAll updates all rows with the specified column values.
+func (q scriptQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+	queries.SetUpdate(q.Query, cols)
+
+	result, err := q.Query.ExecContext(ctx, exec)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update all for script")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected for script")
+	}
+
+	return rowsAff, nil
+}
+
+// UpdateAll updates all rows with the specified column values, using an executor.
+func (o ScriptSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+	ln := int64(len(o))
+	if ln == 0 {
+		return 0, nil
+	}
+
+	if len(cols) == 0 {
+		return 0, errors.New("sqlite3: update all requires at least one column argument")
+	}
+
+	colNames := make([]string, len(cols))
+	args := make([]interface{}, len(cols))
+
+	i := 0
+	for name, value := range cols {
+		colNames[i] = name
+		args[i] = value
+		i++
+	}
+
+	// Append all of the primary key values for each column
+	for _, obj := range o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := fmt.Sprintf("UPDATE \"script\" SET %s WHERE %s",
+		strmangle.SetParamNames("\"", "\"", 0, colNames),
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptPrimaryKeyColumns, len(o)))
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args...)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update all in script slice")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected all in update all script")
+	}
+	return rowsAff, nil
+}
+
+// Delete deletes a single Script record with an executor.
+// Delete will match against the primary key column to find the record to delete.
+func (o *Script) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if o == nil {
+		return 0, errors.New("sqlite3: no Script provided for delete")
+	}
+
+	if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+
+	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), scriptPrimaryKeyMapping)
+	sql := "DELETE FROM \"script\" WHERE \"id\"=?"
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args...)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete from script")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by delete for script")
+	}
+
+	if err := o.doAfterDeleteHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+
+	return rowsAff, nil
+}
+
+// DeleteAll deletes all matching rows.
+func (q scriptQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if q.Query == nil {
+		return 0, errors.New("sqlite3: no scriptQuery provided for delete all")
+	}
+
+	queries.SetDelete(q.Query)
+
+	result, err := q.Query.ExecContext(ctx, exec)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete all from script")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for script")
+	}
+
+	return rowsAff, nil
+}
+
+// DeleteAll deletes all rows in the slice, using an executor.
+func (o ScriptSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if len(o) == 0 {
+		return 0, nil
+	}
+
+	if len(scriptBeforeDeleteHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	var args []interface{}
+	for _, obj := range o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := "DELETE FROM \"script\" WHERE " +
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptPrimaryKeyColumns, len(o))
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete all from script slice")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for script")
+	}
+
+	if len(scriptAfterDeleteHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doAfterDeleteHooks(ctx, exec); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return rowsAff, nil
+}
+
+// Reload refetches the object from the database
+// using the primary keys with an executor.
+func (o *Script) Reload(ctx context.Context, exec boil.ContextExecutor) error {
+	ret, err := FindScript(ctx, exec, o.ID)
+	if err != nil {
+		return err
+	}
+
+	*o = *ret
+	return nil
+}
+
+// ReloadAll refetches every row with matching primary key column values
+// and overwrites the original object slice with the newly updated slice.
+func (o *ScriptSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
+	if o == nil || len(*o) == 0 {
+		return nil
+	}
+
+	slice := ScriptSlice{}
+	var args []interface{}
+	for _, obj := range *o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := "SELECT \"script\".* FROM \"script\" WHERE " +
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptPrimaryKeyColumns, len(*o))
+
+	q := queries.Raw(sql, args...)
+
+	err := q.Bind(ctx, exec, &slice)
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to reload all in ScriptSlice")
+	}
+
+	*o = slice
+
+	return nil
+}
+
+// ScriptExists checks if the Script row exists.
+func ScriptExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) {
+	var exists bool
+	sql := "select exists(select 1 from \"script\" where \"id\"=? limit 1)"
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, iD)
+	}
+
+	row := exec.QueryRowContext(ctx, sql, iD)
+
+	err := row.Scan(&exists)
+	if err != nil {
+		return false, errors.Wrap(err, "sqlite3: unable to check if script exists")
+	}
+
+	return exists, nil
+}

database/models/sqlite3/script_execution.go

@@ -0,0 +1,957 @@
+// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package sqlite3
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/thrasher-corp/sqlboiler/queries"
+	"github.com/thrasher-corp/sqlboiler/queries/qm"
+	"github.com/thrasher-corp/sqlboiler/queries/qmhelper"
+	"github.com/thrasher-corp/sqlboiler/strmangle"
+)
+
+// ScriptExecution is an object representing the database table.
+type ScriptExecution struct {
+	ID              int64  `boil:"id" json:"id" toml:"id" yaml:"id"`
+	ScriptID        string `boil:"script_id" json:"script_id" toml:"script_id" yaml:"script_id"`
+	ExecutionType   string `boil:"execution_type" json:"execution_type" toml:"execution_type" yaml:"execution_type"`
+	ExecutionStatus string `boil:"execution_status" json:"execution_status" toml:"execution_status" yaml:"execution_status"`
+	ExecutionTime   string `boil:"execution_time" json:"execution_time" toml:"execution_time" yaml:"execution_time"`
+
+	R *scriptExecutionR `boil:"-" json:"-" toml:"-" yaml:"-"`
+	L scriptExecutionL  `boil:"-" json:"-" toml:"-" yaml:"-"`
+}
+
+var ScriptExecutionColumns = struct {
+	ID              string
+	ScriptID        string
+	ExecutionType   string
+	ExecutionStatus string
+	ExecutionTime   string
+}{
+	ID:              "id",
+	ScriptID:        "script_id",
+	ExecutionType:   "execution_type",
+	ExecutionStatus: "execution_status",
+	ExecutionTime:   "execution_time",
+}
+
+// Generated where
+
+var ScriptExecutionWhere = struct {
+	ID              whereHelperint64
+	ScriptID        whereHelperstring
+	ExecutionType   whereHelperstring
+	ExecutionStatus whereHelperstring
+	ExecutionTime   whereHelperstring
+}{
+	ID:              whereHelperint64{field: "\"script_execution\".\"id\""},
+	ScriptID:        whereHelperstring{field: "\"script_execution\".\"script_id\""},
+	ExecutionType:   whereHelperstring{field: "\"script_execution\".\"execution_type\""},
+	ExecutionStatus: whereHelperstring{field: "\"script_execution\".\"execution_status\""},
+	ExecutionTime:   whereHelperstring{field: "\"script_execution\".\"execution_time\""},
+}
+
+// ScriptExecutionRels is where relationship names are stored.
+var ScriptExecutionRels = struct {
+	Script string
+}{
+	Script: "Script",
+}
+
+// scriptExecutionR is where relationships are stored.
+type scriptExecutionR struct {
+	Script *Script
+}
+
+// NewStruct creates a new relationship struct
+func (*scriptExecutionR) NewStruct() *scriptExecutionR {
+	return &scriptExecutionR{}
+}
+
+// scriptExecutionL is where Load methods for each relationship are stored.
+type scriptExecutionL struct{}
+
+var (
+	scriptExecutionAllColumns            = []string{"id", "script_id", "execution_type", "execution_status", "execution_time"}
+	scriptExecutionColumnsWithoutDefault = []string{"script_id", "execution_type", "execution_status"}
+	scriptExecutionColumnsWithDefault    = []string{"id", "execution_time"}
+	scriptExecutionPrimaryKeyColumns     = []string{"id"}
+)
+
+type (
+	// ScriptExecutionSlice is an alias for a slice of pointers to ScriptExecution.
+	// This should generally be used opposed to []ScriptExecution.
+	ScriptExecutionSlice []*ScriptExecution
+	// ScriptExecutionHook is the signature for custom ScriptExecution hook methods
+	ScriptExecutionHook func(context.Context, boil.ContextExecutor, *ScriptExecution) error
+
+	scriptExecutionQuery struct {
+		*queries.Query
+	}
+)
+
+// Cache for insert, update and upsert
+var (
+	scriptExecutionType                 = reflect.TypeOf(&ScriptExecution{})
+	scriptExecutionMapping              = queries.MakeStructMapping(scriptExecutionType)
+	scriptExecutionPrimaryKeyMapping, _ = queries.BindMapping(scriptExecutionType, scriptExecutionMapping, scriptExecutionPrimaryKeyColumns)
+	scriptExecutionInsertCacheMut       sync.RWMutex
+	scriptExecutionInsertCache          = make(map[string]insertCache)
+	scriptExecutionUpdateCacheMut       sync.RWMutex
+	scriptExecutionUpdateCache          = make(map[string]updateCache)
+	scriptExecutionUpsertCacheMut       sync.RWMutex
+	scriptExecutionUpsertCache          = make(map[string]insertCache)
+)
+
+var (
+	// Force time package dependency for automated UpdatedAt/CreatedAt.
+	_ = time.Second
+	// Force qmhelper dependency for where clause generation (which doesn't
+	// always happen)
+	_ = qmhelper.Where
+)
+
+var scriptExecutionBeforeInsertHooks []ScriptExecutionHook
+var scriptExecutionBeforeUpdateHooks []ScriptExecutionHook
+var scriptExecutionBeforeDeleteHooks []ScriptExecutionHook
+var scriptExecutionBeforeUpsertHooks []ScriptExecutionHook
+
+var scriptExecutionAfterInsertHooks []ScriptExecutionHook
+var scriptExecutionAfterSelectHooks []ScriptExecutionHook
+var scriptExecutionAfterUpdateHooks []ScriptExecutionHook
+var scriptExecutionAfterDeleteHooks []ScriptExecutionHook
+var scriptExecutionAfterUpsertHooks []ScriptExecutionHook
+
+// doBeforeInsertHooks executes all "before insert" hooks.
+func (o *ScriptExecution) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionBeforeInsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeUpdateHooks executes all "before Update" hooks.
+func (o *ScriptExecution) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionBeforeUpdateHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeDeleteHooks executes all "before Delete" hooks.
+func (o *ScriptExecution) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionBeforeDeleteHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doBeforeUpsertHooks executes all "before Upsert" hooks.
+func (o *ScriptExecution) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionBeforeUpsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterInsertHooks executes all "after Insert" hooks.
+func (o *ScriptExecution) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionAfterInsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterSelectHooks executes all "after Select" hooks.
+func (o *ScriptExecution) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionAfterSelectHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterUpdateHooks executes all "after Update" hooks.
+func (o *ScriptExecution) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionAfterUpdateHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterDeleteHooks executes all "after Delete" hooks.
+func (o *ScriptExecution) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionAfterDeleteHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doAfterUpsertHooks executes all "after Upsert" hooks.
+func (o *ScriptExecution) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+	if boil.HooksAreSkipped(ctx) {
+		return nil
+	}
+
+	for _, hook := range scriptExecutionAfterUpsertHooks {
+		if err := hook(ctx, exec, o); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// AddScriptExecutionHook registers your hook function for all future operations.
+func AddScriptExecutionHook(hookPoint boil.HookPoint, scriptExecutionHook ScriptExecutionHook) {
+	switch hookPoint {
+	case boil.BeforeInsertHook:
+		scriptExecutionBeforeInsertHooks = append(scriptExecutionBeforeInsertHooks, scriptExecutionHook)
+	case boil.BeforeUpdateHook:
+		scriptExecutionBeforeUpdateHooks = append(scriptExecutionBeforeUpdateHooks, scriptExecutionHook)
+	case boil.BeforeDeleteHook:
+		scriptExecutionBeforeDeleteHooks = append(scriptExecutionBeforeDeleteHooks, scriptExecutionHook)
+	case boil.BeforeUpsertHook:
+		scriptExecutionBeforeUpsertHooks = append(scriptExecutionBeforeUpsertHooks, scriptExecutionHook)
+	case boil.AfterInsertHook:
+		scriptExecutionAfterInsertHooks = append(scriptExecutionAfterInsertHooks, scriptExecutionHook)
+	case boil.AfterSelectHook:
+		scriptExecutionAfterSelectHooks = append(scriptExecutionAfterSelectHooks, scriptExecutionHook)
+	case boil.AfterUpdateHook:
+		scriptExecutionAfterUpdateHooks = append(scriptExecutionAfterUpdateHooks, scriptExecutionHook)
+	case boil.AfterDeleteHook:
+		scriptExecutionAfterDeleteHooks = append(scriptExecutionAfterDeleteHooks, scriptExecutionHook)
+	case boil.AfterUpsertHook:
+		scriptExecutionAfterUpsertHooks = append(scriptExecutionAfterUpsertHooks, scriptExecutionHook)
+	}
+}
+
+// One returns a single scriptExecution record from the query.
+func (q scriptExecutionQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ScriptExecution, error) {
+	o := &ScriptExecution{}
+
+	queries.SetLimit(q.Query, 1)
+
+	err := q.Bind(ctx, exec, o)
+	if err != nil {
+		if errors.Cause(err) == sql.ErrNoRows {
+			return nil, sql.ErrNoRows
+		}
+		return nil, errors.Wrap(err, "sqlite3: failed to execute a one query for script_execution")
+	}
+
+	if err := o.doAfterSelectHooks(ctx, exec); err != nil {
+		return o, err
+	}
+
+	return o, nil
+}
+
+// All returns all ScriptExecution records from the query.
+func (q scriptExecutionQuery) All(ctx context.Context, exec boil.ContextExecutor) (ScriptExecutionSlice, error) {
+	var o []*ScriptExecution
+
+	err := q.Bind(ctx, exec, &o)
+	if err != nil {
+		return nil, errors.Wrap(err, "sqlite3: failed to assign all query results to ScriptExecution slice")
+	}
+
+	if len(scriptExecutionAfterSelectHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doAfterSelectHooks(ctx, exec); err != nil {
+				return o, err
+			}
+		}
+	}
+
+	return o, nil
+}
+
+// Count returns the count of all ScriptExecution records in the query.
+func (q scriptExecutionQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	var count int64
+
+	queries.SetSelect(q.Query, nil)
+	queries.SetCount(q.Query)
+
+	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to count script_execution rows")
+	}
+
+	return count, nil
+}
+
+// Exists checks if the row exists in the table.
+func (q scriptExecutionQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
+	var count int64
+
+	queries.SetSelect(q.Query, nil)
+	queries.SetCount(q.Query)
+	queries.SetLimit(q.Query, 1)
+
+	err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+	if err != nil {
+		return false, errors.Wrap(err, "sqlite3: failed to check if script_execution exists")
+	}
+
+	return count > 0, nil
+}
+
+// Script pointed to by the foreign key.
+func (o *ScriptExecution) Script(mods ...qm.QueryMod) scriptQuery {
+	queryMods := []qm.QueryMod{
+		qm.Where("\"id\" = ?", o.ScriptID),
+	}
+
+	queryMods = append(queryMods, mods...)
+
+	query := Scripts(queryMods...)
+	queries.SetFrom(query.Query, "\"script\"")
+
+	return query
+}
+
+// LoadScript allows an eager lookup of values, cached into the
+// loaded structs of the objects. This is for an N-1 relationship.
+func (scriptExecutionL) LoadScript(ctx context.Context, e boil.ContextExecutor, singular bool, maybeScriptExecution interface{}, mods queries.Applicator) error {
+	var slice []*ScriptExecution
+	var object *ScriptExecution
+
+	if singular {
+		object = maybeScriptExecution.(*ScriptExecution)
+	} else {
+		slice = *maybeScriptExecution.(*[]*ScriptExecution)
+	}
+
+	args := make([]interface{}, 0, 1)
+	if singular {
+		if object.R == nil {
+			object.R = &scriptExecutionR{}
+		}
+		args = append(args, object.ScriptID)
+
+	} else {
+	Outer:
+		for _, obj := range slice {
+			if obj.R == nil {
+				obj.R = &scriptExecutionR{}
+			}
+
+			for _, a := range args {
+				if a == obj.ScriptID {
+					continue Outer
+				}
+			}
+
+			args = append(args, obj.ScriptID)
+
+		}
+	}
+
+	if len(args) == 0 {
+		return nil
+	}
+
+	query := NewQuery(qm.From(`script`), qm.WhereIn(`script.id in ?`, args...))
+	if mods != nil {
+		mods.Apply(query)
+	}
+
+	results, err := query.QueryContext(ctx, e)
+	if err != nil {
+		return errors.Wrap(err, "failed to eager load Script")
+	}
+
+	var resultSlice []*Script
+	if err = queries.Bind(results, &resultSlice); err != nil {
+		return errors.Wrap(err, "failed to bind eager loaded slice Script")
+	}
+
+	if err = results.Close(); err != nil {
+		return errors.Wrap(err, "failed to close results of eager load for script")
+	}
+	if err = results.Err(); err != nil {
+		return errors.Wrap(err, "error occurred during iteration of eager loaded relations for script")
+	}
+
+	if len(scriptExecutionAfterSelectHooks) != 0 {
+		for _, obj := range resultSlice {
+			if err := obj.doAfterSelectHooks(ctx, e); err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(resultSlice) == 0 {
+		return nil
+	}
+
+	if singular {
+		foreign := resultSlice[0]
+		object.R.Script = foreign
+		if foreign.R == nil {
+			foreign.R = &scriptR{}
+		}
+		foreign.R.ScriptExecutions = append(foreign.R.ScriptExecutions, object)
+		return nil
+	}
+
+	for _, local := range slice {
+		for _, foreign := range resultSlice {
+			if local.ScriptID == foreign.ID {
+				local.R.Script = foreign
+				if foreign.R == nil {
+					foreign.R = &scriptR{}
+				}
+				foreign.R.ScriptExecutions = append(foreign.R.ScriptExecutions, local)
+				break
+			}
+		}
+	}
+
+	return nil
+}
+
+// SetScript of the scriptExecution to the related item.
+// Sets o.R.Script to related.
+// Adds o to related.R.ScriptExecutions.
+func (o *ScriptExecution) SetScript(ctx context.Context, exec boil.ContextExecutor, insert bool, related *Script) error {
+	var err error
+	if insert {
+		if err = related.Insert(ctx, exec, boil.Infer()); err != nil {
+			return errors.Wrap(err, "failed to insert into foreign table")
+		}
+	}
+
+	updateQuery := fmt.Sprintf(
+		"UPDATE \"script_execution\" SET %s WHERE %s",
+		strmangle.SetParamNames("\"", "\"", 0, []string{"script_id"}),
+		strmangle.WhereClause("\"", "\"", 0, scriptExecutionPrimaryKeyColumns),
+	)
+	values := []interface{}{related.ID, o.ID}
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, updateQuery)
+		fmt.Fprintln(boil.DebugWriter, values)
+	}
+
+	if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil {
+		return errors.Wrap(err, "failed to update local table")
+	}
+
+	o.ScriptID = related.ID
+	if o.R == nil {
+		o.R = &scriptExecutionR{
+			Script: related,
+		}
+	} else {
+		o.R.Script = related
+	}
+
+	if related.R == nil {
+		related.R = &scriptR{
+			ScriptExecutions: ScriptExecutionSlice{o},
+		}
+	} else {
+		related.R.ScriptExecutions = append(related.R.ScriptExecutions, o)
+	}
+
+	return nil
+}
+
+// ScriptExecutions retrieves all the records using an executor.
+func ScriptExecutions(mods ...qm.QueryMod) scriptExecutionQuery {
+	mods = append(mods, qm.From("\"script_execution\""))
+	return scriptExecutionQuery{NewQuery(mods...)}
+}
+
+// FindScriptExecution retrieves a single record by ID with an executor.
+// If selectCols is empty Find will return all columns.
+func FindScriptExecution(ctx context.Context, exec boil.ContextExecutor, iD int64, selectCols ...string) (*ScriptExecution, error) {
+	scriptExecutionObj := &ScriptExecution{}
+
+	sel := "*"
+	if len(selectCols) > 0 {
+		sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
+	}
+	query := fmt.Sprintf(
+		"select %s from \"script_execution\" where \"id\"=?", sel,
+	)
+
+	q := queries.Raw(query, iD)
+
+	err := q.Bind(ctx, exec, scriptExecutionObj)
+	if err != nil {
+		if errors.Cause(err) == sql.ErrNoRows {
+			return nil, sql.ErrNoRows
+		}
+		return nil, errors.Wrap(err, "sqlite3: unable to select from script_execution")
+	}
+
+	return scriptExecutionObj, nil
+}
+
+// Insert a single record using an executor.
+// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
+func (o *ScriptExecution) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
+	if o == nil {
+		return errors.New("sqlite3: no script_execution provided for insertion")
+	}
+
+	var err error
+
+	if err := o.doBeforeInsertHooks(ctx, exec); err != nil {
+		return err
+	}
+
+	nzDefaults := queries.NonZeroDefaultSet(scriptExecutionColumnsWithDefault, o)
+
+	key := makeCacheKey(columns, nzDefaults)
+	scriptExecutionInsertCacheMut.RLock()
+	cache, cached := scriptExecutionInsertCache[key]
+	scriptExecutionInsertCacheMut.RUnlock()
+
+	if !cached {
+		wl, returnColumns := columns.InsertColumnSet(
+			scriptExecutionAllColumns,
+			scriptExecutionColumnsWithDefault,
+			scriptExecutionColumnsWithoutDefault,
+			nzDefaults,
+		)
+
+		cache.valueMapping, err = queries.BindMapping(scriptExecutionType, scriptExecutionMapping, wl)
+		if err != nil {
+			return err
+		}
+		cache.retMapping, err = queries.BindMapping(scriptExecutionType, scriptExecutionMapping, returnColumns)
+		if err != nil {
+			return err
+		}
+		if len(wl) != 0 {
+			cache.query = fmt.Sprintf("INSERT INTO \"script_execution\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
+		} else {
+			cache.query = "INSERT INTO \"script_execution\" () VALUES ()%s%s"
+		}
+
+		var queryOutput, queryReturning string
+
+		if len(cache.retMapping) != 0 {
+			cache.retQuery = fmt.Sprintf("SELECT \"%s\" FROM \"script_execution\" WHERE %s", strings.Join(returnColumns, "\",\""), strmangle.WhereClause("\"", "\"", 0, scriptExecutionPrimaryKeyColumns))
+		}
+
+		cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning)
+	}
+
+	value := reflect.Indirect(reflect.ValueOf(o))
+	vals := queries.ValuesFromMapping(value, cache.valueMapping)
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.query)
+		fmt.Fprintln(boil.DebugWriter, vals)
+	}
+
+	result, err := exec.ExecContext(ctx, cache.query, vals...)
+
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to insert into script_execution")
+	}
+
+	var lastID int64
+	var identifierCols []interface{}
+
+	if len(cache.retMapping) == 0 {
+		goto CacheNoHooks
+	}
+
+	lastID, err = result.LastInsertId()
+	if err != nil {
+		return ErrSyncFail
+	}
+
+	o.ID = int64(lastID)
+	if lastID != 0 && len(cache.retMapping) == 1 && cache.retMapping[0] == scriptExecutionMapping["ID"] {
+		goto CacheNoHooks
+	}
+
+	identifierCols = []interface{}{
+		o.ID,
+	}
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.retQuery)
+		fmt.Fprintln(boil.DebugWriter, identifierCols...)
+	}
+
+	err = exec.QueryRowContext(ctx, cache.retQuery, identifierCols...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to populate default values for script_execution")
+	}
+
+CacheNoHooks:
+	if !cached {
+		scriptExecutionInsertCacheMut.Lock()
+		scriptExecutionInsertCache[key] = cache
+		scriptExecutionInsertCacheMut.Unlock()
+	}
+
+	return o.doAfterInsertHooks(ctx, exec)
+}
+
+// Update uses an executor to update the ScriptExecution.
+// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates.
+// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.
+func (o *ScriptExecution) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
+	var err error
+	if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+	key := makeCacheKey(columns, nil)
+	scriptExecutionUpdateCacheMut.RLock()
+	cache, cached := scriptExecutionUpdateCache[key]
+	scriptExecutionUpdateCacheMut.RUnlock()
+
+	if !cached {
+		wl := columns.UpdateColumnSet(
+			scriptExecutionAllColumns,
+			scriptExecutionPrimaryKeyColumns,
+		)
+
+		if len(wl) == 0 {
+			return 0, errors.New("sqlite3: unable to update script_execution, could not build whitelist")
+		}
+
+		cache.query = fmt.Sprintf("UPDATE \"script_execution\" SET %s WHERE %s",
+			strmangle.SetParamNames("\"", "\"", 0, wl),
+			strmangle.WhereClause("\"", "\"", 0, scriptExecutionPrimaryKeyColumns),
+		)
+		cache.valueMapping, err = queries.BindMapping(scriptExecutionType, scriptExecutionMapping, append(wl, scriptExecutionPrimaryKeyColumns...))
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping)
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, cache.query)
+		fmt.Fprintln(boil.DebugWriter, values)
+	}
+
+	var result sql.Result
+	result, err = exec.ExecContext(ctx, cache.query, values...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update script_execution row")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by update for script_execution")
+	}
+
+	if !cached {
+		scriptExecutionUpdateCacheMut.Lock()
+		scriptExecutionUpdateCache[key] = cache
+		scriptExecutionUpdateCacheMut.Unlock()
+	}
+
+	return rowsAff, o.doAfterUpdateHooks(ctx, exec)
+}
+
+// UpdateAll updates all rows with the specified column values.
+func (q scriptExecutionQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+	queries.SetUpdate(q.Query, cols)
+
+	result, err := q.Query.ExecContext(ctx, exec)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update all for script_execution")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected for script_execution")
+	}
+
+	return rowsAff, nil
+}
+
+// UpdateAll updates all rows with the specified column values, using an executor.
+func (o ScriptExecutionSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+	ln := int64(len(o))
+	if ln == 0 {
+		return 0, nil
+	}
+
+	if len(cols) == 0 {
+		return 0, errors.New("sqlite3: update all requires at least one column argument")
+	}
+
+	colNames := make([]string, len(cols))
+	args := make([]interface{}, len(cols))
+
+	i := 0
+	for name, value := range cols {
+		colNames[i] = name
+		args[i] = value
+		i++
+	}
+
+	// Append all of the primary key values for each column
+	for _, obj := range o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptExecutionPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := fmt.Sprintf("UPDATE \"script_execution\" SET %s WHERE %s",
+		strmangle.SetParamNames("\"", "\"", 0, colNames),
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptExecutionPrimaryKeyColumns, len(o)))
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args...)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to update all in scriptExecution slice")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to retrieve rows affected all in update all scriptExecution")
+	}
+	return rowsAff, nil
+}
+
+// Delete deletes a single ScriptExecution record with an executor.
+// Delete will match against the primary key column to find the record to delete.
+func (o *ScriptExecution) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if o == nil {
+		return 0, errors.New("sqlite3: no ScriptExecution provided for delete")
+	}
+
+	if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+
+	args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), scriptExecutionPrimaryKeyMapping)
+	sql := "DELETE FROM \"script_execution\" WHERE \"id\"=?"
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args...)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete from script_execution")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by delete for script_execution")
+	}
+
+	if err := o.doAfterDeleteHooks(ctx, exec); err != nil {
+		return 0, err
+	}
+
+	return rowsAff, nil
+}
+
+// DeleteAll deletes all matching rows.
+func (q scriptExecutionQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if q.Query == nil {
+		return 0, errors.New("sqlite3: no scriptExecutionQuery provided for delete all")
+	}
+
+	queries.SetDelete(q.Query)
+
+	result, err := q.Query.ExecContext(ctx, exec)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete all from script_execution")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for script_execution")
+	}
+
+	return rowsAff, nil
+}
+
+// DeleteAll deletes all rows in the slice, using an executor.
+func (o ScriptExecutionSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+	if len(o) == 0 {
+		return 0, nil
+	}
+
+	if len(scriptExecutionBeforeDeleteHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	var args []interface{}
+	for _, obj := range o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptExecutionPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := "DELETE FROM \"script_execution\" WHERE " +
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptExecutionPrimaryKeyColumns, len(o))
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, args)
+	}
+
+	result, err := exec.ExecContext(ctx, sql, args...)
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: unable to delete all from scriptExecution slice")
+	}
+
+	rowsAff, err := result.RowsAffected()
+	if err != nil {
+		return 0, errors.Wrap(err, "sqlite3: failed to get rows affected by deleteall for script_execution")
+	}
+
+	if len(scriptExecutionAfterDeleteHooks) != 0 {
+		for _, obj := range o {
+			if err := obj.doAfterDeleteHooks(ctx, exec); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return rowsAff, nil
+}
+
+// Reload refetches the object from the database
+// using the primary keys with an executor.
+func (o *ScriptExecution) Reload(ctx context.Context, exec boil.ContextExecutor) error {
+	ret, err := FindScriptExecution(ctx, exec, o.ID)
+	if err != nil {
+		return err
+	}
+
+	*o = *ret
+	return nil
+}
+
+// ReloadAll refetches every row with matching primary key column values
+// and overwrites the original object slice with the newly updated slice.
+func (o *ScriptExecutionSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
+	if o == nil || len(*o) == 0 {
+		return nil
+	}
+
+	slice := ScriptExecutionSlice{}
+	var args []interface{}
+	for _, obj := range *o {
+		pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), scriptExecutionPrimaryKeyMapping)
+		args = append(args, pkeyArgs...)
+	}
+
+	sql := "SELECT \"script_execution\".* FROM \"script_execution\" WHERE " +
+		strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 0, scriptExecutionPrimaryKeyColumns, len(*o))
+
+	q := queries.Raw(sql, args...)
+
+	err := q.Bind(ctx, exec, &slice)
+	if err != nil {
+		return errors.Wrap(err, "sqlite3: unable to reload all in ScriptExecutionSlice")
+	}
+
+	*o = slice
+
+	return nil
+}
+
+// ScriptExecutionExists checks if the ScriptExecution row exists.
+func ScriptExecutionExists(ctx context.Context, exec boil.ContextExecutor, iD int64) (bool, error) {
+	var exists bool
+	sql := "select exists(select 1 from \"script_execution\" where \"id\"=? limit 1)"
+
+	if boil.DebugMode {
+		fmt.Fprintln(boil.DebugWriter, sql)
+		fmt.Fprintln(boil.DebugWriter, iD)
+	}
+
+	row := exec.QueryRowContext(ctx, sql, iD)
+
+	err := row.Scan(&exists)
+	if err != nil {
+		return false, errors.Wrap(err, "sqlite3: unable to check if script_execution exists")
+	}
+
+	return exists, nil
+}

database/models/sqlite3/script_execution_test.go

@@ -0,0 +1,793 @@
+// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package sqlite3
+
+import (
+	"bytes"
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/thrasher-corp/sqlboiler/queries"
+	"github.com/thrasher-corp/sqlboiler/randomize"
+	"github.com/thrasher-corp/sqlboiler/strmangle"
+)
+
+var (
+	// Relationships sometimes use the reflection helper queries.Equal/queries.Assign
+	// so force a package dependency in case they don't.
+	_ = queries.Equal
+)
+
+func testScriptExecutions(t *testing.T) {
+	t.Parallel()
+
+	query := ScriptExecutions()
+
+	if query.Query == nil {
+		t.Error("expected a query, got nothing")
+	}
+}
+
+func testScriptExecutionsDelete(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := o.Delete(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsQueryDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := ScriptExecutions().DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsSliceDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptExecutionSlice{o}
+
+	if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptExecutionsExists(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	e, err := ScriptExecutionExists(ctx, tx, o.ID)
+	if err != nil {
+		t.Errorf("Unable to check if ScriptExecution exists: %s", err)
+	}
+	if !e {
+		t.Errorf("Expected ScriptExecutionExists to return true, but got false.")
+	}
+}
+
+func testScriptExecutionsFind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	scriptExecutionFound, err := FindScriptExecution(ctx, tx, o.ID)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if scriptExecutionFound == nil {
+		t.Error("want a record, got nil")
+	}
+}
+
+func testScriptExecutionsBind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = ScriptExecutions().Bind(ctx, tx, o); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsOne(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if x, err := ScriptExecutions().One(ctx, tx); err != nil {
+		t.Error(err)
+	} else if x == nil {
+		t.Error("expected to get a non nil record")
+	}
+}
+
+func testScriptExecutionsAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	scriptExecutionOne := &ScriptExecution{}
+	scriptExecutionTwo := &ScriptExecution{}
+	if err = randomize.Struct(seed, scriptExecutionOne, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptExecutionTwo, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptExecutionOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptExecutionTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := ScriptExecutions().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 2 {
+		t.Error("want 2 records, got:", len(slice))
+	}
+}
+
+func testScriptExecutionsCount(t *testing.T) {
+	t.Parallel()
+
+	var err error
+	seed := randomize.NewSeed()
+	scriptExecutionOne := &ScriptExecution{}
+	scriptExecutionTwo := &ScriptExecution{}
+	if err = randomize.Struct(seed, scriptExecutionOne, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptExecutionTwo, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptExecutionOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptExecutionTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 2 {
+		t.Error("want 2 records, got:", count)
+	}
+}
+
+func scriptExecutionBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func scriptExecutionAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ScriptExecution) error {
+	*o = ScriptExecution{}
+	return nil
+}
+
+func testScriptExecutionsHooks(t *testing.T) {
+	t.Parallel()
+
+	var err error
+
+	ctx := context.Background()
+	empty := &ScriptExecution{}
+	o := &ScriptExecution{}
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, false); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution object: %s", err)
+	}
+
+	AddScriptExecutionHook(boil.BeforeInsertHook, scriptExecutionBeforeInsertHook)
+	if err = o.doBeforeInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeInsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterInsertHook, scriptExecutionAfterInsertHook)
+	if err = o.doAfterInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterInsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterSelectHook, scriptExecutionAfterSelectHook)
+	if err = o.doAfterSelectHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterSelectHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterSelectHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeUpdateHook, scriptExecutionBeforeUpdateHook)
+	if err = o.doBeforeUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeUpdateHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterUpdateHook, scriptExecutionAfterUpdateHook)
+	if err = o.doAfterUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterUpdateHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeDeleteHook, scriptExecutionBeforeDeleteHook)
+	if err = o.doBeforeDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeDeleteHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterDeleteHook, scriptExecutionAfterDeleteHook)
+	if err = o.doAfterDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterDeleteHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.BeforeUpsertHook, scriptExecutionBeforeUpsertHook)
+	if err = o.doBeforeUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionBeforeUpsertHooks = []ScriptExecutionHook{}
+
+	AddScriptExecutionHook(boil.AfterUpsertHook, scriptExecutionAfterUpsertHook)
+	if err = o.doAfterUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptExecutionAfterUpsertHooks = []ScriptExecutionHook{}
+}
+
+func testScriptExecutionsInsert(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptExecutionsInsertWhitelist(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Whitelist(scriptExecutionColumnsWithoutDefault...)); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptExecutionToOneScriptUsingScript(t *testing.T) {
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var local ScriptExecution
+	var foreign Script
+
+	seed := randomize.NewSeed()
+	if err := randomize.Struct(seed, &local, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+	if err := randomize.Struct(seed, &foreign, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	local.ScriptID = foreign.ID
+	if err := local.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	check, err := local.Script().One(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if check.ID != foreign.ID {
+		t.Errorf("want: %v, got %v", foreign.ID, check.ID)
+	}
+
+	slice := ScriptExecutionSlice{&local}
+	if err = local.L.LoadScript(ctx, tx, false, (*[]*ScriptExecution)(&slice), nil); err != nil {
+		t.Fatal(err)
+	}
+	if local.R.Script == nil {
+		t.Error("struct should have been eager loaded")
+	}
+
+	local.R.Script = nil
+	if err = local.L.LoadScript(ctx, tx, true, &local, nil); err != nil {
+		t.Fatal(err)
+	}
+	if local.R.Script == nil {
+		t.Error("struct should have been eager loaded")
+	}
+}
+
+func testScriptExecutionToOneSetOpScriptUsingScript(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a ScriptExecution
+	var b, c Script
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, scriptExecutionDBTypes, false, strmangle.SetComplement(scriptExecutionPrimaryKeyColumns, scriptExecutionColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &b, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &c, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	for i, x := range []*Script{&b, &c} {
+		err = a.SetScript(ctx, tx, i != 0, x)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if a.R.Script != x {
+			t.Error("relationship struct not set to correct value")
+		}
+
+		if x.R.ScriptExecutions[0] != &a {
+			t.Error("failed to append to foreign relationship struct")
+		}
+		if a.ScriptID != x.ID {
+			t.Error("foreign key was wrong value", a.ScriptID)
+		}
+
+		zero := reflect.Zero(reflect.TypeOf(a.ScriptID))
+		reflect.Indirect(reflect.ValueOf(&a.ScriptID)).Set(zero)
+
+		if err = a.Reload(ctx, tx); err != nil {
+			t.Fatal("failed to reload", err)
+		}
+
+		if a.ScriptID != x.ID {
+			t.Error("foreign key was wrong value", a.ScriptID, x.ID)
+		}
+	}
+}
+
+func testScriptExecutionsReload(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = o.Reload(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsReloadAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptExecutionSlice{o}
+
+	if err = slice.ReloadAll(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptExecutionsSelect(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := ScriptExecutions().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 1 {
+		t.Error("want one record, got:", len(slice))
+	}
+}
+
+var (
+	scriptExecutionDBTypes = map[string]string{`ID`: `INTEGER`, `ScriptID`: `TEXT`, `ExecutionType`: `TEXT`, `ExecutionStatus`: `TEXT`, `ExecutionTime`: `TIMESTAMP`}
+	_                      = bytes.MinRead
+)
+
+func testScriptExecutionsUpdate(t *testing.T) {
+	t.Parallel()
+
+	if 0 == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with no primary key columns")
+	}
+	if len(scriptExecutionAllColumns) == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only affect one row but affected", rowsAff)
+	}
+}
+
+func testScriptExecutionsSliceUpdateAll(t *testing.T) {
+	t.Parallel()
+
+	if len(scriptExecutionAllColumns) == len(scriptExecutionPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &ScriptExecution{}
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := ScriptExecutions().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptExecutionDBTypes, true, scriptExecutionPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize ScriptExecution struct: %s", err)
+	}
+
+	// Remove Primary keys and unique columns from what we plan to update
+	var fields []string
+	if strmangle.StringSliceMatch(scriptExecutionAllColumns, scriptExecutionPrimaryKeyColumns) {
+		fields = scriptExecutionAllColumns
+	} else {
+		fields = strmangle.SetComplement(
+			scriptExecutionAllColumns,
+			scriptExecutionPrimaryKeyColumns,
+		)
+	}
+
+	value := reflect.Indirect(reflect.ValueOf(o))
+	typ := reflect.TypeOf(o).Elem()
+	n := typ.NumField()
+
+	updateMap := M{}
+	for _, col := range fields {
+		for i := 0; i < n; i++ {
+			f := typ.Field(i)
+			if f.Tag.Get("boil") == col {
+				updateMap[col] = value.Field(i).Interface()
+			}
+		}
+	}
+
+	slice := ScriptExecutionSlice{o}
+	if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("wanted one record updated but got", rowsAff)
+	}
+}

database/models/sqlite3/script_test.go

@@ -0,0 +1,838 @@
+// Code generated by SQLBoiler 3.5.0-gct (https://github.com/thrasher-corp/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package sqlite3
+
+import (
+	"bytes"
+	"context"
+	"reflect"
+	"testing"
+
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/thrasher-corp/sqlboiler/queries"
+	"github.com/thrasher-corp/sqlboiler/randomize"
+	"github.com/thrasher-corp/sqlboiler/strmangle"
+)
+
+var (
+	// Relationships sometimes use the reflection helper queries.Equal/queries.Assign
+	// so force a package dependency in case they don't.
+	_ = queries.Equal
+)
+
+func testScripts(t *testing.T) {
+	t.Parallel()
+
+	query := Scripts()
+
+	if query.Query == nil {
+		t.Error("expected a query, got nothing")
+	}
+}
+
+func testScriptsDelete(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := o.Delete(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptsQueryDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if rowsAff, err := Scripts().DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptsSliceDeleteAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptSlice{o}
+
+	if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only have deleted one row, but affected:", rowsAff)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 0 {
+		t.Error("want zero records, got:", count)
+	}
+}
+
+func testScriptsExists(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	e, err := ScriptExists(ctx, tx, o.ID)
+	if err != nil {
+		t.Errorf("Unable to check if Script exists: %s", err)
+	}
+	if !e {
+		t.Errorf("Expected ScriptExists to return true, but got false.")
+	}
+}
+
+func testScriptsFind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	scriptFound, err := FindScript(ctx, tx, o.ID)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if scriptFound == nil {
+		t.Error("want a record, got nil")
+	}
+}
+
+func testScriptsBind(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = Scripts().Bind(ctx, tx, o); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptsOne(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if x, err := Scripts().One(ctx, tx); err != nil {
+		t.Error(err)
+	} else if x == nil {
+		t.Error("expected to get a non nil record")
+	}
+}
+
+func testScriptsAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	scriptOne := &Script{}
+	scriptTwo := &Script{}
+	if err = randomize.Struct(seed, scriptOne, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptTwo, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := Scripts().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 2 {
+		t.Error("want 2 records, got:", len(slice))
+	}
+}
+
+func testScriptsCount(t *testing.T) {
+	t.Parallel()
+
+	var err error
+	seed := randomize.NewSeed()
+	scriptOne := &Script{}
+	scriptTwo := &Script{}
+	if err = randomize.Struct(seed, scriptOne, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+	if err = randomize.Struct(seed, scriptTwo, scriptDBTypes, false, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = scriptOne.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+	if err = scriptTwo.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 2 {
+		t.Error("want 2 records, got:", count)
+	}
+}
+
+func scriptBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func scriptAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *Script) error {
+	*o = Script{}
+	return nil
+}
+
+func testScriptsHooks(t *testing.T) {
+	t.Parallel()
+
+	var err error
+
+	ctx := context.Background()
+	empty := &Script{}
+	o := &Script{}
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, o, scriptDBTypes, false); err != nil {
+		t.Errorf("Unable to randomize Script object: %s", err)
+	}
+
+	AddScriptHook(boil.BeforeInsertHook, scriptBeforeInsertHook)
+	if err = o.doBeforeInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptBeforeInsertHooks = []ScriptHook{}
+
+	AddScriptHook(boil.AfterInsertHook, scriptAfterInsertHook)
+	if err = o.doAfterInsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterInsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o)
+	}
+	scriptAfterInsertHooks = []ScriptHook{}
+
+	AddScriptHook(boil.AfterSelectHook, scriptAfterSelectHook)
+	if err = o.doAfterSelectHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterSelectHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o)
+	}
+	scriptAfterSelectHooks = []ScriptHook{}
+
+	AddScriptHook(boil.BeforeUpdateHook, scriptBeforeUpdateHook)
+	if err = o.doBeforeUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptBeforeUpdateHooks = []ScriptHook{}
+
+	AddScriptHook(boil.AfterUpdateHook, scriptAfterUpdateHook)
+	if err = o.doAfterUpdateHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpdateHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o)
+	}
+	scriptAfterUpdateHooks = []ScriptHook{}
+
+	AddScriptHook(boil.BeforeDeleteHook, scriptBeforeDeleteHook)
+	if err = o.doBeforeDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptBeforeDeleteHooks = []ScriptHook{}
+
+	AddScriptHook(boil.AfterDeleteHook, scriptAfterDeleteHook)
+	if err = o.doAfterDeleteHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterDeleteHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o)
+	}
+	scriptAfterDeleteHooks = []ScriptHook{}
+
+	AddScriptHook(boil.BeforeUpsertHook, scriptBeforeUpsertHook)
+	if err = o.doBeforeUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptBeforeUpsertHooks = []ScriptHook{}
+
+	AddScriptHook(boil.AfterUpsertHook, scriptAfterUpsertHook)
+	if err = o.doAfterUpsertHooks(ctx, nil); err != nil {
+		t.Errorf("Unable to execute doAfterUpsertHooks: %s", err)
+	}
+	if !reflect.DeepEqual(o, empty) {
+		t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o)
+	}
+	scriptAfterUpsertHooks = []ScriptHook{}
+}
+
+func testScriptsInsert(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptsInsertWhitelist(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Whitelist(scriptColumnsWithoutDefault...)); err != nil {
+		t.Error(err)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+}
+
+func testScriptToManyScriptExecutions(t *testing.T) {
+	var err error
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Script
+	var b, c ScriptExecution
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = randomize.Struct(seed, &b, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &c, scriptExecutionDBTypes, false, scriptExecutionColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+
+	b.ScriptID = a.ID
+	c.ScriptID = a.ID
+
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	check, err := a.ScriptExecutions().All(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bFound, cFound := false, false
+	for _, v := range check {
+		if v.ScriptID == b.ScriptID {
+			bFound = true
+		}
+		if v.ScriptID == c.ScriptID {
+			cFound = true
+		}
+	}
+
+	if !bFound {
+		t.Error("expected to find b")
+	}
+	if !cFound {
+		t.Error("expected to find c")
+	}
+
+	slice := ScriptSlice{&a}
+	if err = a.L.LoadScriptExecutions(ctx, tx, false, (*[]*Script)(&slice), nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.ScriptExecutions); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	a.R.ScriptExecutions = nil
+	if err = a.L.LoadScriptExecutions(ctx, tx, true, &a, nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.ScriptExecutions); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	if t.Failed() {
+		t.Logf("%#v", check)
+	}
+}
+
+func testScriptToManyAddOpScriptExecutions(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Script
+	var b, c, d, e ScriptExecution
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, scriptDBTypes, false, strmangle.SetComplement(scriptPrimaryKeyColumns, scriptColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	foreigners := []*ScriptExecution{&b, &c, &d, &e}
+	for _, x := range foreigners {
+		if err = randomize.Struct(seed, x, scriptExecutionDBTypes, false, strmangle.SetComplement(scriptExecutionPrimaryKeyColumns, scriptExecutionColumnsWithoutDefault)...); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	foreignersSplitByInsertion := [][]*ScriptExecution{
+		{&b, &c},
+		{&d, &e},
+	}
+
+	for i, x := range foreignersSplitByInsertion {
+		err = a.AddScriptExecutions(ctx, tx, i != 0, x...)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		first := x[0]
+		second := x[1]
+
+		if a.ID != first.ScriptID {
+			t.Error("foreign key was wrong value", a.ID, first.ScriptID)
+		}
+		if a.ID != second.ScriptID {
+			t.Error("foreign key was wrong value", a.ID, second.ScriptID)
+		}
+
+		if first.R.Script != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+		if second.R.Script != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+
+		if a.R.ScriptExecutions[i*2] != first {
+			t.Error("relationship struct slice not set to correct value")
+		}
+		if a.R.ScriptExecutions[i*2+1] != second {
+			t.Error("relationship struct slice not set to correct value")
+		}
+
+		count, err := a.ScriptExecutions().Count(ctx, tx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := int64((i + 1) * 2); count != want {
+			t.Error("want", want, "got", count)
+		}
+	}
+}
+
+func testScriptsReload(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	if err = o.Reload(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptsReloadAll(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice := ScriptSlice{o}
+
+	if err = slice.ReloadAll(ctx, tx); err != nil {
+		t.Error(err)
+	}
+}
+
+func testScriptsSelect(t *testing.T) {
+	t.Parallel()
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	slice, err := Scripts().All(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(slice) != 1 {
+		t.Error("want one record, got:", len(slice))
+	}
+}
+
+var (
+	scriptDBTypes = map[string]string{`ID`: `TEXT`, `ScriptID`: `TEXT`, `ScriptName`: `TEXT`, `ScriptPath`: `TEXT`, `ScriptData`: `BLOB`, `LastExecutedAt`: `TIMESTAMP`, `CreatedAt`: `TIMESTAMP`}
+	_             = bytes.MinRead
+)
+
+func testScriptsUpdate(t *testing.T) {
+	t.Parallel()
+
+	if 0 == len(scriptPrimaryKeyColumns) {
+		t.Skip("Skipping table with no primary key columns")
+	}
+	if len(scriptAllColumns) == len(scriptPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("should only affect one row but affected", rowsAff)
+	}
+}
+
+func testScriptsSliceUpdateAll(t *testing.T) {
+	t.Parallel()
+
+	if len(scriptAllColumns) == len(scriptPrimaryKeyColumns) {
+		t.Skip("Skipping table with only primary key columns")
+	}
+
+	seed := randomize.NewSeed()
+	var err error
+	o := &Script{}
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+	if err = o.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Error(err)
+	}
+
+	count, err := Scripts().Count(ctx, tx)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if count != 1 {
+		t.Error("want one record, got:", count)
+	}
+
+	if err = randomize.Struct(seed, o, scriptDBTypes, true, scriptPrimaryKeyColumns...); err != nil {
+		t.Errorf("Unable to randomize Script struct: %s", err)
+	}
+
+	// Remove Primary keys and unique columns from what we plan to update
+	var fields []string
+	if strmangle.StringSliceMatch(scriptAllColumns, scriptPrimaryKeyColumns) {
+		fields = scriptAllColumns
+	} else {
+		fields = strmangle.SetComplement(
+			scriptAllColumns,
+			scriptPrimaryKeyColumns,
+		)
+	}
+
+	value := reflect.Indirect(reflect.ValueOf(o))
+	typ := reflect.TypeOf(o).Elem()
+	n := typ.NumField()
+
+	updateMap := M{}
+	for _, col := range fields {
+		for i := 0; i < n; i++ {
+			f := typ.Field(i)
+			if f.Tag.Get("boil") == col {
+				updateMap[col] = value.Field(i).Interface()
+			}
+		}
+	}
+
+	slice := ScriptSlice{o}
+	if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil {
+		t.Error(err)
+	} else if rowsAff != 1 {
+		t.Error("wanted one record updated but got", rowsAff)
+	}
+}

database/repository/script/script.go

@@ -0,0 +1,126 @@
+package script
+
+import (
+	"context"
+	"time"
+
+	"github.com/gofrs/uuid"
+	"github.com/thrasher-corp/gocryptotrader/database"
+	modelPSQL "github.com/thrasher-corp/gocryptotrader/database/models/postgres"
+	modelSQLite "github.com/thrasher-corp/gocryptotrader/database/models/sqlite3"
+	"github.com/thrasher-corp/gocryptotrader/database/repository"
+	log "github.com/thrasher-corp/gocryptotrader/logger"
+	"github.com/thrasher-corp/sqlboiler/boil"
+	"github.com/volatiletech/null"
+)
+
+// Event inserts a new script event into database with execution details (script name time status hash of script)
+func Event(id, name, path string, data null.Bytes, executionType, status string, time time.Time) {
+	if database.DB.SQL == nil {
+		return
+	}
+
+	ctx := context.Background()
+	ctx = boil.SkipTimestamps(ctx)
+	tx, err := database.DB.SQL.BeginTx(ctx, nil)
+	if err != nil {
+		log.Errorf(log.DatabaseMgr, "Event transaction begin failed: %v", err)
+		return
+	}
+
+	if repository.GetSQLDialect() == database.DBSQLite3 {
+		query := modelSQLite.ScriptWhere.ScriptID.EQ(id)
+		f, errQry := modelSQLite.Scripts(query).Exists(ctx, tx)
+		if errQry != nil {
+			log.Errorf(log.DatabaseMgr, "Query failed: %v", errQry)
+			err = tx.Rollback()
+			if err != nil {
+				log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+			}
+			return
+		}
+		var tempEvent = modelSQLite.Script{}
+		if !f {
+			newUUID, errUUID := uuid.NewV4()
+			if errUUID != nil {
+				log.Errorf(log.DatabaseMgr, "Failed to generate UUID: %v", errUUID)
+				_ = tx.Rollback()
+				return
+			}
+
+			tempEvent.ID = newUUID.String()
+			tempEvent.ScriptID = id
+			tempEvent.ScriptName = name
+			tempEvent.ScriptPath = path
+			tempEvent.ScriptData = data
+			err = tempEvent.Insert(ctx, tx, boil.Infer())
+			if err != nil {
+				log.Errorf(log.DatabaseMgr, "Event insert failed: %v", err)
+				err = tx.Rollback()
+				if err != nil {
+					log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+				}
+				return
+			}
+		} else {
+			tempEvent.ID = id
+		}
+
+		tempScriptExecution := &modelSQLite.ScriptExecution{
+			ScriptID:        id,
+			ExecutionTime:   time.UTC().String(),
+			ExecutionStatus: status,
+			ExecutionType:   executionType,
+		}
+		err = tempEvent.AddScriptExecutions(ctx, tx, true, tempScriptExecution)
+		if err != nil {
+			log.Errorf(log.DatabaseMgr, "Event insert failed: %v", err)
+			err = tx.Rollback()
+			if err != nil {
+				log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+			}
+			return
+		}
+	} else {
+		var tempEvent = modelPSQL.Script{
+			ScriptID:   id,
+			ScriptName: name,
+			ScriptPath: path,
+			ScriptData: data,
+		}
+		err = tempEvent.Upsert(ctx, tx, true, []string{"script_id"}, boil.Whitelist("last_executed_at"), boil.Infer())
+		if err != nil {
+			log.Errorf(log.DatabaseMgr, "Event insert failed: %v", err)
+			err = tx.Rollback()
+			if err != nil {
+				log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+			}
+			return
+		}
+
+		tempScriptExecution := &modelPSQL.ScriptExecution{
+			ExecutionTime:   time.UTC(),
+			ExecutionStatus: status,
+			ExecutionType:   executionType,
+		}
+
+		err = tempEvent.AddScriptExecutions(ctx, tx, true, tempScriptExecution)
+		if err != nil {
+			log.Errorf(log.DatabaseMgr, "Event insert failed: %v", err)
+			err = tx.Rollback()
+			if err != nil {
+				log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+			}
+			return
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		log.Errorf(log.DatabaseMgr, "Event Transaction commit failed: %v", err)
+		err = tx.Rollback()
+		if err != nil {
+			log.Errorf(log.DatabaseMgr, "Event Transaction rollback failed: %v", err)
+		}
+	}
+}

database/tests/script_test.go

@@ -0,0 +1,92 @@
+package tests
+
+import (
+	"fmt"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/thrasher-corp/gocryptotrader/database"
+	"github.com/thrasher-corp/gocryptotrader/database/drivers"
+	"github.com/thrasher-corp/gocryptotrader/database/repository"
+	"github.com/thrasher-corp/gocryptotrader/database/repository/script"
+	"github.com/thrasher-corp/goose"
+	"github.com/volatiletech/null"
+)
+
+func TestScript(t *testing.T) {
+	testCases := []struct {
+		name   string
+		config *database.Config
+		runner func()
+		closer func(t *testing.T, dbConn *database.Db) error
+		output interface{}
+	}{
+		{
+			"SQLite-Write",
+			&database.Config{
+				Driver:            database.DBSQLite3,
+				ConnectionDetails: drivers.ConnectionDetails{Database: "./testdb"},
+			},
+
+			writeScript,
+			closeDatabase,
+			nil,
+		},
+		{
+			"Postgres-Write",
+			postgresTestDatabase,
+			writeScript,
+			nil,
+			nil,
+		},
+	}
+
+	for _, tests := range testCases {
+		test := tests
+
+		t.Run(test.name, func(t *testing.T) {
+			if !checkValidConfig(t, &test.config.ConnectionDetails) {
+				t.Skip("database not configured skipping test")
+			}
+
+			dbConn, err := connectToDatabase(t, test.config)
+
+			if err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join("..", "migrations")
+			err = goose.Run("up", dbConn.SQL, repository.GetSQLDialect(), path, "")
+			if err != nil {
+				t.Fatalf("failed to run migrations %v", err)
+			}
+
+			if test.runner != nil {
+				test.runner()
+			}
+
+			if test.closer != nil {
+				err = test.closer(t, dbConn)
+				if err != nil {
+					t.Log(err)
+				}
+			}
+		})
+	}
+}
+
+func writeScript() {
+	var wg sync.WaitGroup
+	for x := 0; x < 20; x++ {
+		wg.Add(1)
+
+		go func(x int) {
+			defer wg.Done()
+			test := fmt.Sprintf("test-%v", x)
+			var data null.Bytes
+			script.Event(test, test, test, data, test, test, time.Now())
+		}(x)
+	}
+	wg.Wait()
+}