dsmnd

type BasicDatatype ¶

type BasicDatatype Datatype

BasicDatatype is a string that expands upon the SQLite datatypes, mainly by adding "key" and "list" and "clxn" (collection).

• Symbol names: "BDT_" + FOUR UPPER CASE letters
• Symbol values: four lower case letters
• Lists and Collections are included

These are appropriate for describing DB schemas. For more detail tho, use [SemFieldTypes].

But in any case see https://sqlite.org/c3ref/c_blob.html .

func (bdt BasicDatatype) DT() Datatype

func (bdt BasicDatatype) S() string

type ColumnSpec ¶

type ColumnSpec Datum

ColumnSpec specifies a datum (i.e. a struct field and/or a DB column), including its generic/portable/DB-independent representation using the enumeration SemanticFieldType (or else BasicDatatype). It provides enough detail that DB operations can be based on it. Some values for common DB columns are defined in file datadxnry.go . Field usage is as follows:

• Datatype: a value from [SemanticFieldTypes] (via which one can get the value of the BasicDatatype)
• [StorName]: the field name IN THE DB. NOTE: For PKEY or FKEY, is this authoritative ? There could be multiple unique indices, so maybe it should be.
• [DispName]: short description. NOTE: Exception: for FKEY, the name of the ref'd DB table.
• [Description]: long description. NOTE: For FKEY, describe the purpose+function of the ref.

ColumnSpec's are useful in three situations:

• To generate CREATE TABLE statements
• To validate fields with semantic meaning (RSN)
• To document fields when displaying them in a UI

.

func (p *ColumnSpec) String() string

type DB_type ¶

type DB_type string

const (
	// DB_SQLite is NOT "sqlite3"!
	DB_SQLite DB_type = "sqlite"
)

type Datatype ¶

type Datatype string

Datatype can be either a BasicDatatype (`BDT_*`) or a SemanticType (`SFT_* SCT_*`). We don't normally want to intermix these two, but it is necessary when defining the first field of a Datum.

type Datum ¶

type Datum struct {
	// BasicDatatype is an SQLite fundamental datatype,
	// enhanced with Primary Key and Foreign Key.
	// TODO: SemanticType (FUTURE).
	Datatype // BasicDatatype
	// StorName is a short unique string token - no
	// spaces or punctuation. For robustness we use
	// string codes not iota-based integer values,
	// because values based on iota could change.
	//  1) When a Datum describes a DB item (table or
	//     column or row's column value), StorName is
	//     the actual name of the DB field or table,
	//     and should be all lower case
	//  2) When a Datum describes an enumeration (set)
	//     or facet, StorName should be all upper case,
	//     and all values of a StorNames in a particular
	//     enumeration "should" be of the same length.
	StorName string
	// DispName is for common use by users when brief
	// is better, such as for column headers.
	DispName string
	// Description is a long-form description.
	Description string
}

Datum is a datum descriptor that contains a data type (a value from one of several sets), a storage name (for when persisted), a short display name (for users), and a freetext description.

NOTE: When used as an enum node (ELIST) or enum value (ENUME), a Datum will need the addition of a namespace and isSet/hasKids.

A Datum can be used to describe any of the following:

• A table spec (schema) for a database
• A table spec (schema) as present in a database
• A column spec for a DB table
• A field value in a Go struct
• A facet or enumeration
• One value in a facet or enumeration
• An enumeration (set), or a higher node in a hierarchical structure of facets/enumerations

Some example use cases (TODO: this needs revising):

An element of an enumeration (example: Language)

• DataType: TEXT ("text")
• StorName: "EN", "FR"
• DispName: "English", "French"
• Description: "English (default USA)", "French (default France)"

A database table:

• e.g. TableSpec{TABL, "inbatch", "INB", "Batch import of files"}
• DataType: TABL ("tabl")
• StorName: "inbatch" (in SQL "CREATE TABLE")
• DispName: "inb" (when used as a prefix, e.g. "inb_idx"))
• Description: "Input batch of imported files"

A database column:

• e.g. ColumnSpec{TEXT, "relfp", "Rel. path", "Rel.FP (from CLI)"}
• DataType: PKEY ("pkey") OOPS, PATH?
• StorName: "relfp"
• DispName: "Rel. path"
• Description: "Rel.FP (from CLI)"

The DataType might sometimes be optional, but not other fields.

NOTE: The discussion that follows (ref: https://www.sqlite.org/datatype3.html) is mostly obsolete now, because we have expanded the set of permissible values for [BasicDataType]...

The SQLite concepts "storage class" and "affinity" are quite similar. The values for these are "INTEGER", "REAL", "NUMERIC, "TEXT", "BLOB". (Note that primary and foreign keys are overloaded with "INTEGER"). It turns out that all of them are both classes/affinities AND ("mostly") specific data types, so they are simple to use if we can ignore details.

For purposes of comparison, note that the dataframe library "gota" uses "string", "int", "float", "bool". We will not use a BOOL data type anywhere, and anyways a BOOL can be stored in SQLite as an INTEGER limited to (0,1).

Furthermore, in SQLite it seems that "BLOBs are always stored as BLOBs regardless of column affinity".

This all means that we can basically

1. completely ignore SQLite NUMERIC, SQLite BLOB, and gota BOOL,
2. declare every column to be either "INTG" or "TEXT" (in BasicDataType),
3. but use "INTEGER" (i.e. "KEYY") for a key (primary or foreign), and
4. not worry about "mistakes" like assigning a BLOB (like an image file) to a TEXT column cos SQLite has got us covered.

.

func (d Datum) String() string

type DbColInDb ¶

type DbColInDb Datum

DbColInDb describes a column as-is in the DB (as obtained via reflection), and has a slot to include the value (as a string). Used only in utils/repo/sqlite/meta_table.go .

type GoBasicKind ¶

type GoBasicKind types.BasicKind

See https://pkg.go.dev/go/types#BasicKind:

• type BasicKind int
• const (
• Invalid BasicKind = iota // type is invalid
• predeclared types
• Bool Int Int8 Int16 Int32 Int64 Uint Uint8 Uint16 Uint32 Uint64
• Uintptr Float32 Float64 Complex64 Complex128 String UnsafePointer
• types for untyped values
• UntypedBool UntypedInt UntypedRune UntypedFloat
• UntypedComplex UntypedString UntypedNil
• aliases
• Byte = Uint8
• Rune = Int32

.

type InUI ¶

type InUI struct {
	Visible, Enabled, Selected bool
	Position                   int
}

InUI is meant to be embedded in any struct that uses a Datum to store an entry in a UI.

type JsonSchemaBuiltinFormat ¶

type JsonSchemaBuiltinFormat Datum

See https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats

type NSPath ¶

type NSPath struct {
	NS   string
	Path string
}

NSPath is pretty generic and can represent just about anything. Examples:

• Imported file: batch nr + abs/rel.path
• Disk file: PC FQN + abs.pah
• Facet value: facet FQN + hiercal path

.

type SemanticClxnDescriptor ¶

type SemanticClxnDescriptor SemanticDescriptor

SemanticClxnDescriptor is TBS.

func SemanticClxnDescriptorByType(sct SemanticClxnType) (SemanticClxnDescriptor, error)

type SemanticClxnType ¶

type SemanticClxnType SemanticType

SemanticClxnType characterizes the semantics of data structures more complex than simple lists. ENUME is included because it (a) uses a Datum and (b) also can implement the hierarchical naming scheme for faceted metadata and other enumerations.

• Symbol names: "SCT_" + FIVE UPPER CASE letters
• Symbol values: five lower case letters

For more information about each field type, see SemanticClxnDescriptors. .

func (sct SemanticClxnType) DT() Datatype

func (sct SemanticClxnType) S() string

type SemanticDescriptor ¶

type SemanticDescriptor Datum

type SemanticFieldDescriptor ¶

type SemanticFieldDescriptor SemanticDescriptor

SemanticFieldDescriptor details the semantics of a simple field. An app that uses SemanticFieldDescriptor's should know how to handle each field type, so that the app can in each case:

1. create the appropriate SQLite field, and
2. create a translation layer btwn the app and SQLite, and
3. create the proper rendering in HTML (or plain text), and
4. maybe do basic validation

N.B. An "enume" is: one value in an enumeration. .

func SemanticFieldDescriptorByType(sft SemanticFieldType) (SemanticFieldDescriptor, error)

type SemanticFieldType ¶

type SemanticFieldType SemanticType

SemanticFieldType assigns the semantics of a simple field. Semantically-based field validation is desirable but TBD.

• Symbol names: "SFT_" + FIVE UPPER CASE letters
• Symbol values: five lower case alphanumeric

For more information about each field type, see SemanticFieldDescriptors. .

func (sft SemanticFieldType) BasicDatatype() BasicDatatype

func (sft SemanticFieldType) DT() Datatype

func (sft SemanticFieldType) Descriptor() SemanticFieldDescriptor

func (sft SemanticFieldType) S() string

type SemanticListDescriptor ¶

type SemanticListDescriptor SemanticDescriptor

SemanticListDescriptor details the semantics of a simple list. An app that uses SemanticListDescriptor's should know how to handle each field type, so that the app can in each case:

1. create the appropriate SQLite field (single/multi value), and
2. create a translation layer btwn the app and SQLite, and
3. create the proper HTML widget (or plain text UI)

N.B. An "enume" is: one value in an enumeration. .

func SemanticListDescriptorByType(slt SemanticListType) (SemanticListDescriptor, error)

type SemanticListType ¶

type SemanticListType SemanticType

SemanticListType assigns the semantics of a simple list.

• Symbol names: "SFT_" + FIVE UPPER CASE letters
• Symbol values: five lower case letters

For more information about each field type, see SemanticListDescriptors. .

func (slt SemanticListType) DT() Datatype

func (slt SemanticListType) S() string

type SemanticType ¶

type SemanticType Datatype

type SqliteDatatype ¶

type SqliteDatatype int

SqliteDatatype is one of the five basic ones defined by & for SQLite, plus the addition of a date-time. See https://sqlite.org/c3ref/c_blob.html

There's also complicating factors like NUMERIC (and REAL). .

type TableSummary ¶

type TableSummary Datum

TableSummary sums up a DB table (but not its columns). Field usage is as follows:

• Datatype: SCT_TABL
• [StorName]: the name of the table IN THE DB - a "long name"
• [DispName]: a short name (3 ltrs!) for use in building up field names (mainly: primary & foreign keys)
• [Description]: long description

.

type TypeType ¶

type TypeType string

TypeType enumerates the basic types defined in this package. Datum is not in this list. .