ds

type Config struct {
	Fields          []Field
	TypeOf          string
	PrimaryKey      string
	Indexes         []string
	Uniques         []string
	LastInsertIndex uint64
	Version         int
}

type Field struct {
	Name string
	Tag  string
	Type string
}

type GetOptions struct {
	// Should the results be sorted. Does nothing for unsorted tables
	Sorted bool
	// If results are to be sorted, should they be from most recent to oldest (true) or invese (false)
	Ascending bool
	// The maximum number of entries to return. 0 means unlimited
	Max int
}

type IReadTransaction[T any] interface {
	// Get will get a single entry by its primary key. Returns (nil, nil) if nothing found.
	Get(primaryKey any) (*T, error)
	// GetIndex will get multiple entries that contain the same value for the specified indexed field.
	// Result is not ordered. Use GetIndexSorted to return a sorted slice.
	// Returns an empty array if nothing found.
	GetIndex(fieldName string, value any, options *GetOptions) ([]*T, error)
	// GetUnique will get a single entry based on the value of the provided unique field.
	// Returns (nil, nil) if nothing found.
	GetUnique(fieldName string, value any) (*T, error)
	// GetAll will get all of the entries in the table.
	GetAll(options *GetOptions) ([]*T, error)
}

type IReadWriteTransaction[T any] interface {
	IReadTransaction[T]
	// Add will add a new object to the table. o must the the same type that was used to register the table and cannot be a pointer.
	Add(o T) error
	// Delete will delete the provided object and clean indexes
	Delete(o T) error
	// DeletePrimaryKey will delete the object with the associated primary key and clean indexes. Does nothing if not object
	// matches the given primary key.
	DeletePrimaryKey(o any) error
	// DeleteUnique will delete the object with the associated unique value and clean indexes. Does nothing if no object
	// matched the given unique fields value.
	DeleteUnique(field string, o any) error
	// DeleteAllIndex will delete all objects matching the given indexed fields value
	DeleteAllIndex(fieldName string, value any) error
	// DeleteAll delete all objects from the table
	DeleteAll() error
	// Update will update an existing object in the table. The primary key must match for this object
	// otherwise it will just be inserted as a new object. Updated objects do not change positions in a sorted
	// table.
	Update(o T) error
}

type MigrateParams[OldType any, NewType any] struct {
	// TablePath the path to the existing table file
	TablePath string
	// NewPath (optional) is the path for the new table file. If blank then the existing table path is re-used.
	NewPath string
	// DisableSorting (optional) if the current table is sorted, set this to true to disable sorting
	// Note: This is irreversible!
	DisableSorting bool
	// MigrateObject method called for each entry in the table in reverse order. Return a new type, error, or nil.
	// Migration is halted if an error is returned.
	// Return (nil, nil) and the entry will be skipped from migration, but migration will continue.
	MigrateObject func(o *OldType) (*NewType, error)
	// KeepBackup (optional) if false the backup copy of the table will be discarded if the migration was successful. If
	// true, the copy is not deleted.
	KeepBackup bool
}

type MigrationResults struct {
	// Success was the migration successful
	Success bool
	// Error if unsuccessful, this will be the error that caused the failure
	Error error
	// EntriesMigrated the number of entries migrated
	EntriesMigrated uint
	// EntriesSkipped the number of entries skipped
	EntriesSkipped uint
}

type Options struct {
	// DisableSorting disable all sorting features. This will make tables smaller, and inserts/removes/deletes faster.
	DisableSorting bool
	// contains filtered or unexported fields
}

type Table[T any] struct {
	Name string
	// contains filtered or unexported fields
}