repoutils

type DAO ¶

type DAO struct{}

These are in app model packages but not here I guess.

type DbOp ¶

type DbOp string

type Field ¶

type Field interface {
	~byte | ~int16 | ~int32 | ~int64 | ~float64 |
		~string | ~bool | time.Time
}

Field is a type constraint for types that represent

• a single database column, or
• any other non-struct datum, such as an int64 primary index.

type QuerySpec ¶

type QuerySpec struct {
	DbOp
	// Table must not be empty; if it is treated as
	// case-insensitive then no validity checking
	// is done.
	Table string
	// Fields must not be empty, for consistency
	// in technique re. using ptrs everywhere in
	// order to enable generics and Scan(..).
	Fields string
	// ID can safely be ignored if
	// (IDs != nil) && (ID == 0 || ID == -1)
	ID int64
	// IDs != nil is an error if ID is valid.
	IDs   []int64
	Where string
}

QuerySpec is the basic strings that get plugged into a query: table name, column names, "where" clause. It is meant to be passed to query composers (not "builders") that are specific to various DBs. Which means, for now, SQLite.

A query composer might also be a query executor, which would mean distinguiishing at the API level among return values of int64, []int64, Row, and []Row.

There is redundancy built in, to help ensure against errors in usage: the DB op, the presence or absence of a WHERE clause, the number of IDs passed (0, 1, N). .

type Repo ¶

type Repo struct {
	*sql.DB
	Path string
}

var R Repo

func (R *Repo) RunQuery1(qs QuerySpec) (any, error)

type Row ¶

type Row[T any] interface {
	// PtrFields returns a slice of
	// ptrs, one per struct field,
	// for use with [Row.Scan].
	// Implement it for - and call
	// it with - ptr receivers ONLY.
	PtrFields() []any // TODO Try []*any

	*T
}

Row is a type constraint for types that

• represent a single database row, and
• therefore correspond to a Go struct.

According to this definition, a Row can

• cough up a set of ptrs suitable for setting every field/column, and
• have its own address be taken (and passed around), making it writable.

type SqlarRow ¶

type SqlarRow struct {
}

SqlarRow gas structure defined by SQLite.

func (p *SqlarRow) String() string

type TableDescriptor ¶

type TableDescriptor struct {
	// Name is the name of the table in the DB,
	// e.g. inbatch, contentity, topicref.
	Name string
	// Shortname is a short version for use in the
	// names of other variables, e.g. inb, cnt, trf.
	ShortName string
	// IDName is the name of the index field, which (for now)
	// we use in the same format BOTH for a primary key AND
	// as a foreign key.
	IDName string
	// ColumnNames is all column names (except primary key), in a
	// specified order, comma-separated, for use in SQL statements.
	// We omit the primary key so that we can use this for SQL
	// INSERT staements too.
	ColumnNames string
	// We used to have ForenKeys defined by name only, but this is
	// insufficient information, because we need the field name AND
	// the table name. In principle we could derive one from the
	// other using our other DB-related data structures, and maybe
	// we used to, but it adds significant complexity.
	// ForenKeys   []string
	ColumnSpecs []D.ColumnSpec
}

TableDescriptor describes the field structure of a database table. or each table, a primary key is assumed and foreign keys are allowed.

All text fields should be in lower-case. Enforcement of this will inevitably be patchy.

Notes on particular fields:

• The field [ColumnSpecs] is a slice of [db.ColumnSpec], which is [dsmnd.Datum] and has four text fields: [Fundatype], StorNam, DispName, Descrription.
• The field [ForenKeys] may be nil or length [0].
• TODO: (Maybe): the field [ColumnSpecs] could be nil or len 0. If so then it should "probably" be autogenerated (partially only) by reflection from the contents of a same-named table currently existing in the DB.

Notes on date-time fields:

• These are not an issue for SQLite, since either a string or an int can be used. However, date-time fields referenced using THIS system (i.e. [db.TableDescriptor] and [db.DbColumnSpec]) use strings (SQLite DDL "TEXT"), which are expected to be ISO-8601 / RFC 3339 (and probly UTC). It is the first option listed in https://www.sqlite.org/datatype3.html#date_and_time_datatype:
• TEXT: "YYYY-MM-DD HH:MM:SS.SSS"
• REAL as Julian day numbers: the day count since 24 November 4714 BC
• INTEGER as Unix time: the seconds count since 1970-01-01 00:00:00 UTC
• NOTE: For TEXT "YYYY-MM-DD HH:MM:SS.SSS", this might often end up in ISO format, which has a "T" instead of the blank " " . So for better readability, and to avoid line breaks, we have a utility that replaces either a blank (" ") or an ISO "T" with a "_".

.

type Times ¶

type Times struct {
	T_Cre string
	T_Imp string
	T_Edt string
}

Times has (create, import, last edit) and uses only ISO-8601 / RFC 3339.