@g9tm/lynxcontrols-sqlite 2.3.0 → 2.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/catalog/catalog.json +2137 -0
- package/catalog/index.md +4 -0
- package/dist/.tsbuildinfo +1 -1
- package/package.json +6 -4
|
@@ -0,0 +1,2137 @@
|
|
|
1
|
+
{
|
|
2
|
+
"catalogVersion": 1,
|
|
3
|
+
"package": "@g9tm/lynxcontrols-sqlite",
|
|
4
|
+
"version": "2.4.1",
|
|
5
|
+
"generatedBy": "node scripts/check-docs.mjs --write",
|
|
6
|
+
"components": [],
|
|
7
|
+
"exports": [
|
|
8
|
+
{
|
|
9
|
+
"id": "sqlite.sqlite.add",
|
|
10
|
+
"export": "add",
|
|
11
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
12
|
+
"kind": "function",
|
|
13
|
+
"signature": "(left: G9Operand<number>, right: G9Operand<number>): G9Expr",
|
|
14
|
+
"summary": "Arithmetic (always parenthesised in SQL, so the tree's grouping survives)."
|
|
15
|
+
},
|
|
16
|
+
{
|
|
17
|
+
"id": "sqlite.sqlite.addInt64",
|
|
18
|
+
"export": "addInt64",
|
|
19
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
20
|
+
"kind": "function",
|
|
21
|
+
"signature": "(a: G9Int64, b: G9Int64): G9Int64",
|
|
22
|
+
"summary": "a + b; throws `misuse` on int64 overflow (never wraps silently)."
|
|
23
|
+
},
|
|
24
|
+
{
|
|
25
|
+
"id": "sqlite.sqlite.and",
|
|
26
|
+
"export": "and",
|
|
27
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
28
|
+
"kind": "function",
|
|
29
|
+
"signature": "(...items: (false | G9Expr | null | undefined)[]): G9Expr",
|
|
30
|
+
"summary": "Logical AND of the given predicates (falsy entries are skipped, so conditional parts read naturally)."
|
|
31
|
+
},
|
|
32
|
+
{
|
|
33
|
+
"id": "sqlite.sqlite.applyInsertDefaults",
|
|
34
|
+
"export": "applyInsertDefaults",
|
|
35
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
36
|
+
"kind": "function",
|
|
37
|
+
"signature": "(entity: G9EntityDescriptor<any>, row: Row, now: G9LocalDateTime, userId: string | null, idCase?: G9IdCase): void",
|
|
38
|
+
"summary": "MAUI `SqliteEntityAuditDefaults.ApplyInsertDefaults`: normalises or mints the id, sets created and updated time to `now`, and both user columns to `userId` — or, with no user, to whichever user the row already carried. No-op for an entity that is not audited."
|
|
39
|
+
},
|
|
40
|
+
{
|
|
41
|
+
"id": "sqlite.sqlite.applyUpdateDefaults",
|
|
42
|
+
"export": "applyUpdateDefaults",
|
|
43
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
44
|
+
"kind": "function",
|
|
45
|
+
"signature": "(entity: G9EntityDescriptor<any>, row: Row, now: G9LocalDateTime, userId: string | null, idCase?: G9IdCase): void",
|
|
46
|
+
"summary": "MAUI `SqliteEntityAuditDefaults.ApplyUpdateDefaults`: normalises or mints the id, refreshes updated time, and the updating user only when one is signed in (a background job never erases who last touched the row)."
|
|
47
|
+
},
|
|
48
|
+
{
|
|
49
|
+
"id": "sqlite.sqlite.applyUpsertDefaults",
|
|
50
|
+
"export": "applyUpsertDefaults",
|
|
51
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
52
|
+
"kind": "function",
|
|
53
|
+
"signature": "(entity: G9EntityDescriptor<any>, row: Row, now: G9LocalDateTime, userId: string | null, idCase?: G9IdCase): void",
|
|
54
|
+
"summary": "MAUI `ApplyUpsertAuditIfNeeded`: insert defaults when the row has no creator or creation time yet, else update."
|
|
55
|
+
},
|
|
56
|
+
{
|
|
57
|
+
"id": "sqlite.sqlite.auditColumns",
|
|
58
|
+
"export": "auditColumns",
|
|
59
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
60
|
+
"kind": "function",
|
|
61
|
+
"signature": "(): { id: G9Column<string, false, true>; createdTime: G9Column<G9LocalDateTime, false, true>; updatedTime: G9Column<G9LocalDateTime, false, true>; createdByUserId: G9Column<string, true, true>; updatedByUserId: G9Column<string, true, true>; }",
|
|
62
|
+
"summary": "The five audit columns of MAUI `IG9AuditedEntity` (`Id`, `CreatedTime`, `UpdatedTime`, `CreatedByUserId`, `UpdatedByUserId`), each optional on insert. Spread them into an entity to make it audited."
|
|
63
|
+
},
|
|
64
|
+
{
|
|
65
|
+
"id": "sqlite.sqlite.avg",
|
|
66
|
+
"export": "avg",
|
|
67
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
68
|
+
"kind": "function",
|
|
69
|
+
"signature": "(operand: G9Operand<number>): G9Expr",
|
|
70
|
+
"summary": "`AVG(col)`."
|
|
71
|
+
},
|
|
72
|
+
{
|
|
73
|
+
"id": "sqlite.sqlite.between",
|
|
74
|
+
"export": "between",
|
|
75
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
76
|
+
"kind": "function",
|
|
77
|
+
"signature": "<T>(operand: G9Operand<T>, low: G9Operand<T>, high: G9Operand<T>): G9Expr",
|
|
78
|
+
"summary": "`col BETWEEN low AND high` (inclusive)."
|
|
79
|
+
},
|
|
80
|
+
{
|
|
81
|
+
"id": "sqlite.sqlite.blob",
|
|
82
|
+
"export": "blob",
|
|
83
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
84
|
+
"kind": "function",
|
|
85
|
+
"signature": "(): G9Column<ArrayBuffer, false, false>",
|
|
86
|
+
"summary": "BLOB as `ArrayBuffer`."
|
|
87
|
+
},
|
|
88
|
+
{
|
|
89
|
+
"id": "sqlite.sqlite.blobCodec",
|
|
90
|
+
"export": "blobCodec",
|
|
91
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
92
|
+
"kind": "constant",
|
|
93
|
+
"signature": "G9Codec<ArrayBuffer>",
|
|
94
|
+
"summary": "BLOB as `ArrayBuffer` (typed arrays are copied in). Empty ≠ NULL."
|
|
95
|
+
},
|
|
96
|
+
{
|
|
97
|
+
"id": "sqlite.sqlite.bool",
|
|
98
|
+
"export": "bool",
|
|
99
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
100
|
+
"kind": "function",
|
|
101
|
+
"signature": "(): G9Column<boolean, false, false>",
|
|
102
|
+
"summary": "0/1 boolean."
|
|
103
|
+
},
|
|
104
|
+
{
|
|
105
|
+
"id": "sqlite.sqlite.boolCodec",
|
|
106
|
+
"export": "boolCodec",
|
|
107
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
108
|
+
"kind": "constant",
|
|
109
|
+
"signature": "G9Codec<boolean>",
|
|
110
|
+
"summary": "Boolean stored as 0/1. Any other stored value fails (a NULL is not false: make the column nullable)."
|
|
111
|
+
},
|
|
112
|
+
{
|
|
113
|
+
"id": "sqlite.sqlite.bytesToHex",
|
|
114
|
+
"export": "bytesToHex",
|
|
115
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
116
|
+
"kind": "function",
|
|
117
|
+
"signature": "(bytes: ArrayBuffer): string",
|
|
118
|
+
"summary": "Lower-case hex of a BLOB (diagnostics and SQL literals)."
|
|
119
|
+
},
|
|
120
|
+
{
|
|
121
|
+
"id": "sqlite.sqlite.checksumText",
|
|
122
|
+
"export": "checksumText",
|
|
123
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
124
|
+
"kind": "function",
|
|
125
|
+
"signature": "(text: string): string",
|
|
126
|
+
"summary": "FNV-1a 64-bit over UTF-16 code units, as 16 hex digits (two 32-bit halves; no BigInt)."
|
|
127
|
+
},
|
|
128
|
+
{
|
|
129
|
+
"id": "sqlite.sqlite.coalesce",
|
|
130
|
+
"export": "coalesce",
|
|
131
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
132
|
+
"kind": "function",
|
|
133
|
+
"signature": "(primary: unknown, fallback: unknown): G9Expr",
|
|
134
|
+
"summary": "`COALESCE(primary, fallback)`."
|
|
135
|
+
},
|
|
136
|
+
{
|
|
137
|
+
"id": "sqlite.sqlite.codecOf",
|
|
138
|
+
"export": "codecOf",
|
|
139
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
140
|
+
"kind": "function",
|
|
141
|
+
"signature": "(expr: G9Expr): G9Codec<unknown> | undefined",
|
|
142
|
+
"summary": "Codec of a column reference, for binding the other side of a comparison."
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
"id": "sqlite.sqlite.colEq",
|
|
146
|
+
"export": "colEq",
|
|
147
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
148
|
+
"kind": "function",
|
|
149
|
+
"signature": "<T>(left: G9Expr | G9ColumnRef<T>, right: G9Expr | G9ColumnRef<T>): G9Expr",
|
|
150
|
+
"summary": "Column-to-column equality, emitted as plain `a = b` exactly as MAUI did for `x.A == x.B` (NULLs do not match)."
|
|
151
|
+
},
|
|
152
|
+
{
|
|
153
|
+
"id": "sqlite.sqlite.collectColumns",
|
|
154
|
+
"export": "collectColumns",
|
|
155
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
156
|
+
"kind": "function",
|
|
157
|
+
"signature": "(expr: G9Expr, out?: G9ColumnRef<unknown>[]): G9ColumnRef<unknown>[]",
|
|
158
|
+
"summary": "Collects every column reference in an expression (for `whereLocalized`)."
|
|
159
|
+
},
|
|
160
|
+
{
|
|
161
|
+
"id": "sqlite.sqlite.columnSql",
|
|
162
|
+
"export": "columnSql",
|
|
163
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
164
|
+
"kind": "function",
|
|
165
|
+
"signature": "(ref: G9ColumnRef<unknown>, ctx: G9CompileContext): string",
|
|
166
|
+
"summary": "The column's SQL: quoted, qualified when the query has joins, and localized under a culture."
|
|
167
|
+
},
|
|
168
|
+
{
|
|
169
|
+
"id": "sqlite.sqlite.compareIds",
|
|
170
|
+
"export": "compareIds",
|
|
171
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
172
|
+
"kind": "function",
|
|
173
|
+
"signature": "(left: string | null | undefined, right: string | null | undefined): number",
|
|
174
|
+
"summary": "Case-insensitive ordinal order of two ids (sorting by id)."
|
|
175
|
+
},
|
|
176
|
+
{
|
|
177
|
+
"id": "sqlite.sqlite.compareInt64",
|
|
178
|
+
"export": "compareInt64",
|
|
179
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
180
|
+
"kind": "function",
|
|
181
|
+
"signature": "(a: G9Int64, b: G9Int64): number",
|
|
182
|
+
"summary": "Total order of two int64 values: negative, zero or positive."
|
|
183
|
+
},
|
|
184
|
+
{
|
|
185
|
+
"id": "sqlite.sqlite.compareLocalDateTime",
|
|
186
|
+
"export": "compareLocalDateTime",
|
|
187
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
188
|
+
"kind": "function",
|
|
189
|
+
"signature": "(a: G9LocalDateTime, b: G9LocalDateTime): number",
|
|
190
|
+
"summary": "Chronological order of two values: negative, zero or positive."
|
|
191
|
+
},
|
|
192
|
+
{
|
|
193
|
+
"id": "sqlite.sqlite.compileExpr",
|
|
194
|
+
"export": "compileExpr",
|
|
195
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
196
|
+
"kind": "function",
|
|
197
|
+
"signature": "(expr: G9Expr, ctx: G9CompileContext): G9SqlFragment",
|
|
198
|
+
"summary": "Compiles an expression tree to SQL and parameters."
|
|
199
|
+
},
|
|
200
|
+
{
|
|
201
|
+
"id": "sqlite.sqlite.contains",
|
|
202
|
+
"export": "contains",
|
|
203
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
204
|
+
"kind": "function",
|
|
205
|
+
"signature": "(operand: G9Operand<string>, fragment: string): G9Expr",
|
|
206
|
+
"summary": "C# `x.Name.Contains(s)`: `LIKE '%s%' ESCAPE '\\'` with `%`, `_`, `\\` in `s` escaped."
|
|
207
|
+
},
|
|
208
|
+
{
|
|
209
|
+
"id": "sqlite.sqlite.contractToSqlValue",
|
|
210
|
+
"export": "contractToSqlValue",
|
|
211
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
212
|
+
"kind": "function",
|
|
213
|
+
"signature": "(value: G9ContractValue): G9SqlValue",
|
|
214
|
+
"summary": "Turns a contract value into a driver value."
|
|
215
|
+
},
|
|
216
|
+
{
|
|
217
|
+
"id": "sqlite.sqlite.converted",
|
|
218
|
+
"export": "converted",
|
|
219
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
220
|
+
"kind": "function",
|
|
221
|
+
"signature": "<TModel, TStore>(store: G9Codec<TStore>, converter: G9ValueConverter<TModel, TStore>): G9Column<TModel, false, false>",
|
|
222
|
+
"summary": "MAUI `IG9ValueConverter`: a model type stored through another codec."
|
|
223
|
+
},
|
|
224
|
+
{
|
|
225
|
+
"id": "sqlite.sqlite.convertedCodec",
|
|
226
|
+
"export": "convertedCodec",
|
|
227
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
228
|
+
"kind": "function",
|
|
229
|
+
"signature": "<TModel, TStore>(store: G9Codec<TStore>, converter: G9ValueConverter<TModel, TStore>, kind?: string): G9Codec<TModel>",
|
|
230
|
+
"summary": "Wraps a store codec with a `G9ValueConverter`."
|
|
231
|
+
},
|
|
232
|
+
{
|
|
233
|
+
"id": "sqlite.sqlite.count",
|
|
234
|
+
"export": "count",
|
|
235
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
236
|
+
"kind": "function",
|
|
237
|
+
"signature": "(operand?: unknown): G9Expr",
|
|
238
|
+
"summary": "MAUI `SqliteAggregateMaker.Count()` / `Count(column)`: `COUNT(*)` or `COUNT(col)`."
|
|
239
|
+
},
|
|
240
|
+
{
|
|
241
|
+
"id": "sqlite.sqlite.countWhen",
|
|
242
|
+
"export": "countWhen",
|
|
243
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
244
|
+
"kind": "function",
|
|
245
|
+
"signature": "(condition: G9Expr): G9Expr",
|
|
246
|
+
"summary": "MAUI `CountWhen(condition)`: `COALESCE(SUM(CASE WHEN (cond) THEN 1 ELSE 0 END), 0)`."
|
|
247
|
+
},
|
|
248
|
+
{
|
|
249
|
+
"id": "sqlite.sqlite.createColumnRefs",
|
|
250
|
+
"export": "createColumnRefs",
|
|
251
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
252
|
+
"kind": "function",
|
|
253
|
+
"signature": "<C extends G9Columns>(columns: readonly G9EntityColumn[], scope: G9QueryScope): G9ColumnRefs<C>",
|
|
254
|
+
"summary": "Builds refs for one occurrence of an entity in a query."
|
|
255
|
+
},
|
|
256
|
+
{
|
|
257
|
+
"id": "sqlite.sqlite.createG9Sqlite",
|
|
258
|
+
"export": "createG9Sqlite",
|
|
259
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
260
|
+
"kind": "function",
|
|
261
|
+
"signature": "(options: G9SqliteOptions): G9Sqlite",
|
|
262
|
+
"summary": "Creates the persistence layer (MAUI `services.AddG9Sqlite(...)`). Configuration errors (duplicate migration versions, invalid options) throw here; the connection opens on first use, running migrations, index DDL and initializers once per database path."
|
|
263
|
+
},
|
|
264
|
+
{
|
|
265
|
+
"id": "sqlite.sqlite.createIndexSql",
|
|
266
|
+
"export": "createIndexSql",
|
|
267
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
268
|
+
"kind": "function",
|
|
269
|
+
"signature": "(entity: G9EntityDescriptor<any>, codecContext?: G9CodecContext): string[]",
|
|
270
|
+
"summary": "Deterministic DDL for an entity's declared indexes (N07): order, collation, partial predicate; a unique index on a soft-delete entity covers live rows only unless `includeDeleted`. Partial predicates are inlined (SQLite does not allow parameters in index definitions)."
|
|
271
|
+
},
|
|
272
|
+
{
|
|
273
|
+
"id": "sqlite.sqlite.createLocalDateTime",
|
|
274
|
+
"export": "createLocalDateTime",
|
|
275
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
276
|
+
"kind": "function",
|
|
277
|
+
"signature": "(fields: { year: number; month: number; day: number; hour?: number; minute?: number; second?: number; ticks?: number; }): G9LocalDateTime",
|
|
278
|
+
"summary": "Validates and freezes a `G9LocalDateTime`. Throws `misuse` for an impossible date or time."
|
|
279
|
+
},
|
|
280
|
+
{
|
|
281
|
+
"id": "sqlite.sqlite.createOffsetAuditClock",
|
|
282
|
+
"export": "createOffsetAuditClock",
|
|
283
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
284
|
+
"kind": "function",
|
|
285
|
+
"signature": "(offsetMinutes: number, clock?: G9Clock): G9AuditClock",
|
|
286
|
+
"summary": "A clock at a fixed UTC offset (e.g. a business time zone without DST, `+210` for Tehran since 2022). For zones with DST, implement `G9AuditClock` with the app's own zone rules: G9 never guesses a zone."
|
|
287
|
+
},
|
|
288
|
+
{
|
|
289
|
+
"id": "sqlite.sqlite.createSystemAuditClock",
|
|
290
|
+
"export": "createSystemAuditClock",
|
|
291
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
292
|
+
"kind": "function",
|
|
293
|
+
"signature": "(clock?: G9Clock): G9AuditClock",
|
|
294
|
+
"summary": "MAUI `G9SystemClock`: UTC wall time. The default."
|
|
295
|
+
},
|
|
296
|
+
{
|
|
297
|
+
"id": "sqlite.sqlite.createTableSql",
|
|
298
|
+
"export": "createTableSql",
|
|
299
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
300
|
+
"kind": "function",
|
|
301
|
+
"signature": "(entity: G9EntityDescriptor<any>): string",
|
|
302
|
+
"summary": "Deterministic `CREATE TABLE IF NOT EXISTS` for an entity."
|
|
303
|
+
},
|
|
304
|
+
{
|
|
305
|
+
"id": "sqlite.sqlite.custom",
|
|
306
|
+
"export": "custom",
|
|
307
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
308
|
+
"kind": "function",
|
|
309
|
+
"signature": "<T>(codec: G9Codec<T>): G9Column<T, false, false>",
|
|
310
|
+
"summary": "A column with a custom codec."
|
|
311
|
+
},
|
|
312
|
+
{
|
|
313
|
+
"id": "sqlite.sqlite.daysInMonth",
|
|
314
|
+
"export": "daysInMonth",
|
|
315
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
316
|
+
"kind": "function",
|
|
317
|
+
"signature": "(year: number, month: number): number",
|
|
318
|
+
"summary": "Days in a month of the proleptic Gregorian calendar."
|
|
319
|
+
},
|
|
320
|
+
{
|
|
321
|
+
"id": "sqlite.sqlite.decimalText",
|
|
322
|
+
"export": "decimalText",
|
|
323
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
324
|
+
"kind": "function",
|
|
325
|
+
"signature": "(): G9Column<string, false, false>",
|
|
326
|
+
"summary": "Exact decimal kept as TEXT."
|
|
327
|
+
},
|
|
328
|
+
{
|
|
329
|
+
"id": "sqlite.sqlite.decimalTextCodec",
|
|
330
|
+
"export": "decimalTextCodec",
|
|
331
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
332
|
+
"kind": "constant",
|
|
333
|
+
"signature": "G9Codec<string>",
|
|
334
|
+
"summary": "A decimal kept as exact text (`\"12.3400\"` keeps its scale). Declare the column TEXT: a NUMERIC/REAL affinity column converts the text to a double on store, which is exactly the loss this codec exists to avoid; such a value is read back as the double's shortest decimal text."
|
|
335
|
+
},
|
|
336
|
+
{
|
|
337
|
+
"id": "sqlite.sqlite.defineEntity",
|
|
338
|
+
"export": "defineEntity",
|
|
339
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
340
|
+
"kind": "function",
|
|
341
|
+
"signature": "<C extends G9Columns>(name: string, columns: C, configure?: ((entity: G9EntityBuilder<C>) => unknown) | undefined): G9EntityDescriptor<C>",
|
|
342
|
+
"summary": "Defines an entity (MAUI: an entity class + `G9SqliteBuilder.Entity<T>(…)`). Validation happens here, so an invalid descriptor fails at definition, never at the first query."
|
|
343
|
+
},
|
|
344
|
+
{
|
|
345
|
+
"id": "sqlite.sqlite.defineInitializer",
|
|
346
|
+
"export": "defineInitializer",
|
|
347
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
348
|
+
"kind": "function",
|
|
349
|
+
"signature": "(definition: { name: string; mode?: \"once\" | \"everyOpen\"; run: (context: G9MigrationContext) => unknown; }): G9Initializer",
|
|
350
|
+
"summary": "Defines an initializer (`once` by default: a durable, recorded seed)."
|
|
351
|
+
},
|
|
352
|
+
{
|
|
353
|
+
"id": "sqlite.sqlite.defineInterceptor",
|
|
354
|
+
"export": "defineInterceptor",
|
|
355
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
356
|
+
"kind": "function",
|
|
357
|
+
"signature": "(interceptor: G9SqliteInterceptor): G9SqliteInterceptor",
|
|
358
|
+
"summary": "MAUI `G9SqliteInterceptor` base class equivalent: an identity helper that keeps the object literal typed."
|
|
359
|
+
},
|
|
360
|
+
{
|
|
361
|
+
"id": "sqlite.sqlite.defineMigration",
|
|
362
|
+
"export": "defineMigration",
|
|
363
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
364
|
+
"kind": "function",
|
|
365
|
+
"signature": "(definition: { version: number; name: string; sql: readonly string[]; transactional?: boolean; } | { version: number; name: string; checksum: string; up: (context: G9MigrationContext) => unknown; transactional?: boolean; }): G9Migration",
|
|
366
|
+
"summary": "Defines a migration. Give `sql` (statements run in order; the checksum is derived from them) or `up` with an explicit `checksum` (bump it whenever the code changes meaning)."
|
|
367
|
+
},
|
|
368
|
+
{
|
|
369
|
+
"id": "sqlite.sqlite.describeSqlValue",
|
|
370
|
+
"export": "describeSqlValue",
|
|
371
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
372
|
+
"kind": "function",
|
|
373
|
+
"signature": "(value: unknown): string",
|
|
374
|
+
"summary": "A short, privacy-safe description of a value's kind for error messages."
|
|
375
|
+
},
|
|
376
|
+
{
|
|
377
|
+
"id": "sqlite.sqlite.div",
|
|
378
|
+
"export": "div",
|
|
379
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
380
|
+
"kind": "function",
|
|
381
|
+
"signature": "(left: G9Operand<number>, right: G9Operand<number>): G9Expr",
|
|
382
|
+
"summary": "Arithmetic `/` (parenthesised)."
|
|
383
|
+
},
|
|
384
|
+
{
|
|
385
|
+
"id": "sqlite.sqlite.encodeParam",
|
|
386
|
+
"export": "encodeParam",
|
|
387
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
388
|
+
"kind": "function",
|
|
389
|
+
"signature": "(value: unknown, codec: G9Codec<unknown> | undefined, context: G9CodecContext): G9SqlValue",
|
|
390
|
+
"summary": "Encodes a value bound in a query. With the codec of the column it is compared to (GUID normalisation, 0/1 booleans, lossless int64, date text); otherwise by its JavaScript type (MAUI `NormalizeParam`)."
|
|
391
|
+
},
|
|
392
|
+
{
|
|
393
|
+
"id": "sqlite.sqlite.endsWith",
|
|
394
|
+
"export": "endsWith",
|
|
395
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
396
|
+
"kind": "function",
|
|
397
|
+
"signature": "(operand: G9Operand<string>, suffix: string): G9Expr",
|
|
398
|
+
"summary": "C# `EndsWith`: `LIKE '%s' ESCAPE '\\'`."
|
|
399
|
+
},
|
|
400
|
+
{
|
|
401
|
+
"id": "sqlite.sqlite.entityFilters",
|
|
402
|
+
"export": "entityFilters",
|
|
403
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
404
|
+
"kind": "function",
|
|
405
|
+
"signature": "(entity: AnyEntity, deleted: DeletedMode, options: G9BuildOptions): G9Expr[]",
|
|
406
|
+
"summary": "Filters an entity contributes to a managed query: always-filter and soft-delete visibility."
|
|
407
|
+
},
|
|
408
|
+
{
|
|
409
|
+
"id": "sqlite.sqlite.enumInt",
|
|
410
|
+
"export": "enumInt",
|
|
411
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
412
|
+
"kind": "function",
|
|
413
|
+
"signature": "<K extends string>(members: Readonly<Record<K, number>>): G9Column<K, false, false>",
|
|
414
|
+
"summary": "Enum stored as its integer."
|
|
415
|
+
},
|
|
416
|
+
{
|
|
417
|
+
"id": "sqlite.sqlite.enumIntCodec",
|
|
418
|
+
"export": "enumIntCodec",
|
|
419
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
420
|
+
"kind": "function",
|
|
421
|
+
"signature": "<K extends string>(members: Readonly<Record<K, number>>): G9Codec<K>",
|
|
422
|
+
"summary": "An enum stored as its integer (MAUI `NormalizeParam`: `Convert.ToInt32(enum)`). The model value is the name; an unknown stored number fails rather than inventing a member."
|
|
423
|
+
},
|
|
424
|
+
{
|
|
425
|
+
"id": "sqlite.sqlite.enumText",
|
|
426
|
+
"export": "enumText",
|
|
427
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
428
|
+
"kind": "function",
|
|
429
|
+
"signature": "<K extends string>(members: readonly K[]): G9Column<K, false, false>",
|
|
430
|
+
"summary": "Enum stored as its name."
|
|
431
|
+
},
|
|
432
|
+
{
|
|
433
|
+
"id": "sqlite.sqlite.enumTextCodec",
|
|
434
|
+
"export": "enumTextCodec",
|
|
435
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
436
|
+
"kind": "function",
|
|
437
|
+
"signature": "<K extends string>(members: readonly K[]): G9Codec<K>",
|
|
438
|
+
"summary": "An enum stored as its name (TEXT)."
|
|
439
|
+
},
|
|
440
|
+
{
|
|
441
|
+
"id": "sqlite.sqlite.eq",
|
|
442
|
+
"export": "eq",
|
|
443
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
444
|
+
"kind": "function",
|
|
445
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
446
|
+
"summary": "C# `==`: `col = ?`, or `col IS NULL` when the value is null (a captured null too). Two columns compare with plain `=` (MAUI left join conditions untouched). Two values use `IS`."
|
|
447
|
+
},
|
|
448
|
+
{
|
|
449
|
+
"id": "sqlite.sqlite.formatLegacyDateTime",
|
|
450
|
+
"export": "formatLegacyDateTime",
|
|
451
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
452
|
+
"kind": "function",
|
|
453
|
+
"signature": "(value: G9LocalDateTime, profile?: G9DateTimeWriteProfile): string",
|
|
454
|
+
"summary": "Writes a `G9LocalDateTime` in the given profile (default `provider`, the MAUI connection format)."
|
|
455
|
+
},
|
|
456
|
+
{
|
|
457
|
+
"id": "sqlite.sqlite.G9_DATETIME_MIN",
|
|
458
|
+
"export": "G9_DATETIME_MIN",
|
|
459
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
460
|
+
"kind": "constant",
|
|
461
|
+
"signature": "G9LocalDateTime",
|
|
462
|
+
"summary": ".NET `default(DateTime)`: 0001-01-01 00:00:00. MAUI used it to mean \"not set\"."
|
|
463
|
+
},
|
|
464
|
+
{
|
|
465
|
+
"id": "sqlite.sqlite.G9_INT64_MAX",
|
|
466
|
+
"export": "G9_INT64_MAX",
|
|
467
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
468
|
+
"kind": "constant",
|
|
469
|
+
"signature": "G9Int64",
|
|
470
|
+
"summary": "The largest int64, `2^63 − 1`."
|
|
471
|
+
},
|
|
472
|
+
{
|
|
473
|
+
"id": "sqlite.sqlite.G9_INT64_MIN",
|
|
474
|
+
"export": "G9_INT64_MIN",
|
|
475
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
476
|
+
"kind": "constant",
|
|
477
|
+
"signature": "G9Int64",
|
|
478
|
+
"summary": "The smallest int64, `-2^63`."
|
|
479
|
+
},
|
|
480
|
+
{
|
|
481
|
+
"id": "sqlite.sqlite.G9_MAX_IN_LIST_PARAMETERS",
|
|
482
|
+
"export": "G9_MAX_IN_LIST_PARAMETERS",
|
|
483
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
484
|
+
"kind": "constant",
|
|
485
|
+
"signature": "16000",
|
|
486
|
+
"summary": "MAUI's IN-list placeholder budget: half of SQLite's 32 766 per-statement variables."
|
|
487
|
+
},
|
|
488
|
+
{
|
|
489
|
+
"id": "sqlite.sqlite.G9_SCHEMA_HISTORY_COLUMNS",
|
|
490
|
+
"export": "G9_SCHEMA_HISTORY_COLUMNS",
|
|
491
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
492
|
+
"kind": "constant",
|
|
493
|
+
"signature": "readonly [\"Kind\", \"Key\", \"Version\", \"Name\", \"Checksum\", \"AppliedAt\"]",
|
|
494
|
+
"summary": "Columns the history table must have; anything else under that name is a collision, not ours."
|
|
495
|
+
},
|
|
496
|
+
{
|
|
497
|
+
"id": "sqlite.sqlite.G9_SCHEMA_HISTORY_DDL",
|
|
498
|
+
"export": "G9_SCHEMA_HISTORY_DDL",
|
|
499
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
500
|
+
"kind": "constant",
|
|
501
|
+
"signature": "string",
|
|
502
|
+
"summary": "DDL of the schema-history table (applied migrations and initializers, with checksums)."
|
|
503
|
+
},
|
|
504
|
+
{
|
|
505
|
+
"id": "sqlite.sqlite.G9_SCHEMA_HISTORY_TABLE",
|
|
506
|
+
"export": "G9_SCHEMA_HISTORY_TABLE",
|
|
507
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
508
|
+
"kind": "constant",
|
|
509
|
+
"signature": "\"g9lynx_schema_history\"",
|
|
510
|
+
"summary": "The G9 history table (never `PRAGMA user_version`, which G9SyncData may own)."
|
|
511
|
+
},
|
|
512
|
+
{
|
|
513
|
+
"id": "sqlite.sqlite.G9AuditClock",
|
|
514
|
+
"export": "G9AuditClock",
|
|
515
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
516
|
+
"kind": "interface",
|
|
517
|
+
"signature": "G9AuditClock",
|
|
518
|
+
"summary": "Supplies \"now\" for audit columns (MAUI `IG9Clock`). Read at write time, never captured: a captured value would freeze at startup."
|
|
519
|
+
},
|
|
520
|
+
{
|
|
521
|
+
"id": "sqlite.sqlite.G9AuditMapping",
|
|
522
|
+
"export": "G9AuditMapping",
|
|
523
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
524
|
+
"kind": "interface",
|
|
525
|
+
"signature": "G9AuditMapping",
|
|
526
|
+
"summary": "The MAUI `IG9AuditedEntity` mapping: which properties hold the audit facts."
|
|
527
|
+
},
|
|
528
|
+
{
|
|
529
|
+
"id": "sqlite.sqlite.G9BoundValue",
|
|
530
|
+
"export": "G9BoundValue",
|
|
531
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
532
|
+
"kind": "type",
|
|
533
|
+
"signature": "G9SqlValue",
|
|
534
|
+
"summary": "A value already in driver form; used by the compiler for its own parameters."
|
|
535
|
+
},
|
|
536
|
+
{
|
|
537
|
+
"id": "sqlite.sqlite.G9BuildOptions",
|
|
538
|
+
"export": "G9BuildOptions",
|
|
539
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
540
|
+
"kind": "interface",
|
|
541
|
+
"signature": "G9BuildOptions",
|
|
542
|
+
"summary": "Settings for building a statement outside a database (MAUI's static factory read process-wide settings)."
|
|
543
|
+
},
|
|
544
|
+
{
|
|
545
|
+
"id": "sqlite.sqlite.G9BusyOptions",
|
|
546
|
+
"export": "G9BusyOptions",
|
|
547
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
548
|
+
"kind": "interface",
|
|
549
|
+
"signature": "G9BusyOptions",
|
|
550
|
+
"summary": "Bounded retry around whole transactions when SQLite reports `busy` (MAUI `UseBusyRetry`, N10)."
|
|
551
|
+
},
|
|
552
|
+
{
|
|
553
|
+
"id": "sqlite.sqlite.G9CacheHandle",
|
|
554
|
+
"export": "G9CacheHandle",
|
|
555
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
556
|
+
"kind": "interface",
|
|
557
|
+
"signature": "G9CacheHandle<T>",
|
|
558
|
+
"summary": "An in-memory copy of a small, hot table or a DTO projection over tables (MAUI repository cache and `SqliteDtoCache`). Invalidated only by committed writes (never by a rollback), coalesced by the policy's debounce, bounded by `maxRows`, optionally expiring, and reset on a user switch so no row of one user reaches the next."
|
|
559
|
+
},
|
|
560
|
+
{
|
|
561
|
+
"id": "sqlite.sqlite.G9CachePolicy",
|
|
562
|
+
"export": "G9CachePolicy",
|
|
563
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
564
|
+
"kind": "constant",
|
|
565
|
+
"signature": "{ readonly immediate: (options?: { maxRows?: number; ttlMs?: number; }) => G9CachePolicy; readonly debounced: (debounceMs?: number, options?: { maxRows?: number; ttlMs?: number; }) => G9CachePolicy; readonly all: (maxRows: number, options?: { debounceMs?: number; ttlMs?: number; }) => G9CachePolicy; readonly ttl: (ttlMs: number, options?: { debounceMs?: number; maxRows?: number; }) => G9CachePolic",
|
|
566
|
+
"summary": "Whether and how an entity's rows are cached in memory (MAUI `G9CachePolicy`). For small, hot, rarely-written reference tables: the cache holds every (filtered) row and a committed write invalidates it. Cache policy factories (MAUI `G9CachePolicy.Immediate()` / `.Debounced(250)` plus TTL and size bounds)."
|
|
567
|
+
},
|
|
568
|
+
{
|
|
569
|
+
"id": "sqlite.sqlite.G9ChangeEvent",
|
|
570
|
+
"export": "G9ChangeEvent",
|
|
571
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
572
|
+
"kind": "interface",
|
|
573
|
+
"signature": "G9ChangeEvent",
|
|
574
|
+
"summary": "One committed change, published to `db.onChange` listeners once per committed write."
|
|
575
|
+
},
|
|
576
|
+
{
|
|
577
|
+
"id": "sqlite.sqlite.G9Codec",
|
|
578
|
+
"export": "G9Codec",
|
|
579
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
580
|
+
"kind": "interface",
|
|
581
|
+
"signature": "G9Codec<T>",
|
|
582
|
+
"summary": "Converts one column between the model value and the stored `G9SqlValue` (MAUI `IG9ValueConverter` plus the mapping sqlite-net did by reflection). Codecs never see NULL: the column decides nullability."
|
|
583
|
+
},
|
|
584
|
+
{
|
|
585
|
+
"id": "sqlite.sqlite.G9CodecContext",
|
|
586
|
+
"export": "G9CodecContext",
|
|
587
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
588
|
+
"kind": "interface",
|
|
589
|
+
"signature": "G9CodecContext",
|
|
590
|
+
"summary": "Database-wide settings a codec reads while converting (fixed per `createG9Sqlite`)."
|
|
591
|
+
},
|
|
592
|
+
{
|
|
593
|
+
"id": "sqlite.sqlite.G9Collation",
|
|
594
|
+
"export": "G9Collation",
|
|
595
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
596
|
+
"kind": "type",
|
|
597
|
+
"signature": "G9Collation",
|
|
598
|
+
"summary": "SQLite collations G9 declares."
|
|
599
|
+
},
|
|
600
|
+
{
|
|
601
|
+
"id": "sqlite.sqlite.G9Column",
|
|
602
|
+
"export": "G9Column",
|
|
603
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
604
|
+
"kind": "class",
|
|
605
|
+
"signature": "typeof G9Column",
|
|
606
|
+
"summary": "A column declaration. Immutable: every modifier returns a new column. `T` is the model type, `N` whether it is nullable (`null` = SQL NULL), `G` whether it may be omitted on insert."
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
"id": "sqlite.sqlite.G9ColumnCase",
|
|
610
|
+
"export": "G9ColumnCase",
|
|
611
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
612
|
+
"kind": "type",
|
|
613
|
+
"signature": "G9ColumnCase",
|
|
614
|
+
"summary": "How column names are derived from property names."
|
|
615
|
+
},
|
|
616
|
+
{
|
|
617
|
+
"id": "sqlite.sqlite.G9ColumnRef",
|
|
618
|
+
"export": "G9ColumnRef",
|
|
619
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
620
|
+
"kind": "interface",
|
|
621
|
+
"signature": "G9ColumnRef<T>",
|
|
622
|
+
"summary": "A reference to one column of one entity occurrence in a query. Predicates receive an object of these (`(x) => eq(x.parentId, parent)`); the compiler turns it into a quoted, alias-qualified column."
|
|
623
|
+
},
|
|
624
|
+
{
|
|
625
|
+
"id": "sqlite.sqlite.G9ColumnRefs",
|
|
626
|
+
"export": "G9ColumnRefs",
|
|
627
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
628
|
+
"kind": "type",
|
|
629
|
+
"signature": "G9ColumnRefs<C>",
|
|
630
|
+
"summary": "Column references of an entity, keyed by property: what predicates receive."
|
|
631
|
+
},
|
|
632
|
+
{
|
|
633
|
+
"id": "sqlite.sqlite.G9Columns",
|
|
634
|
+
"export": "G9Columns",
|
|
635
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
636
|
+
"kind": "type",
|
|
637
|
+
"signature": "G9Columns",
|
|
638
|
+
"summary": "A record of named columns: an entity's shape."
|
|
639
|
+
},
|
|
640
|
+
{
|
|
641
|
+
"id": "sqlite.sqlite.G9ColumnSpec",
|
|
642
|
+
"export": "G9ColumnSpec",
|
|
643
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
644
|
+
"kind": "interface",
|
|
645
|
+
"signature": "G9ColumnSpec",
|
|
646
|
+
"summary": "Static facts of one column, before it is attached to an entity."
|
|
647
|
+
},
|
|
648
|
+
{
|
|
649
|
+
"id": "sqlite.sqlite.G9CompareOp",
|
|
650
|
+
"export": "G9CompareOp",
|
|
651
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
652
|
+
"kind": "type",
|
|
653
|
+
"signature": "G9CompareOp",
|
|
654
|
+
"summary": "`eq`/`ne` carry C# null semantics (MAUI's builder); `sqlEq`/`sqlNe` are plain SQL; `is`/`isNot` are SQLite's null-safe `IS` / `IS NOT`."
|
|
655
|
+
},
|
|
656
|
+
{
|
|
657
|
+
"id": "sqlite.sqlite.G9CompileContext",
|
|
658
|
+
"export": "G9CompileContext",
|
|
659
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
660
|
+
"kind": "interface",
|
|
661
|
+
"signature": "G9CompileContext",
|
|
662
|
+
"summary": "Settings of one compilation."
|
|
663
|
+
},
|
|
664
|
+
{
|
|
665
|
+
"id": "sqlite.sqlite.G9ConflictPolicy",
|
|
666
|
+
"export": "G9ConflictPolicy",
|
|
667
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
668
|
+
"kind": "enum",
|
|
669
|
+
"signature": "G9ConflictPolicy",
|
|
670
|
+
"summary": "What an INSERT does when a key collides (MAUI `G9ConflictPolicy`). - `abort` (default): fail with a `constraint` error. A surprise collision is usually a bug worth hearing about. - `ignore`: skip the row (`INSERT OR IGNORE`); the returned count excludes it. - `replace`: `INSERT OR REPLACE`, which SQLite executes as DELETE + INSERT: columns the row does not supply reset to their defaults, and the implicit delete fires DELETE triggers only under `PRAGMA recursive_triggers=ON` (default OFF), so sync capture triggers do not see it. Only when asked for explicitly. - an upsert (`upsert`): `ON CONFLICT (target) DO UPDATE SET` the given (or every supplied non-key) columns, leaving the rest and the audit creation fields intact. MAUI `Upsert`. MAUI `G9ConflictPolicy` members by their C# names."
|
|
671
|
+
},
|
|
672
|
+
{
|
|
673
|
+
"id": "sqlite.sqlite.G9ConnectionPragmas",
|
|
674
|
+
"export": "G9ConnectionPragmas",
|
|
675
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
676
|
+
"kind": "interface",
|
|
677
|
+
"signature": "G9ConnectionPragmas",
|
|
678
|
+
"summary": "Per-connection PRAGMA values a driver applies on open, before any statement (names are whitelisted)."
|
|
679
|
+
},
|
|
680
|
+
{
|
|
681
|
+
"id": "sqlite.sqlite.G9ContractCase",
|
|
682
|
+
"export": "G9ContractCase",
|
|
683
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
684
|
+
"kind": "interface",
|
|
685
|
+
"signature": "G9ContractCase",
|
|
686
|
+
"summary": "One contract case: an id, its group, and the steps run against a fresh database."
|
|
687
|
+
},
|
|
688
|
+
{
|
|
689
|
+
"id": "sqlite.sqlite.G9ContractCases",
|
|
690
|
+
"export": "G9ContractCases",
|
|
691
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
692
|
+
"kind": "interface",
|
|
693
|
+
"signature": "G9ContractCases",
|
|
694
|
+
"summary": "The shared contract file (`@g9tm/lynxcontrols-sqlite/contract/cases.json`) every driver runs."
|
|
695
|
+
},
|
|
696
|
+
{
|
|
697
|
+
"id": "sqlite.sqlite.G9ContractExpectation",
|
|
698
|
+
"export": "G9ContractExpectation",
|
|
699
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
700
|
+
"kind": "interface",
|
|
701
|
+
"signature": "G9ContractExpectation",
|
|
702
|
+
"summary": "What one statement must return; only the fields given are compared."
|
|
703
|
+
},
|
|
704
|
+
{
|
|
705
|
+
"id": "sqlite.sqlite.G9ContractFailure",
|
|
706
|
+
"export": "G9ContractFailure",
|
|
707
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
708
|
+
"kind": "interface",
|
|
709
|
+
"signature": "G9ContractFailure",
|
|
710
|
+
"summary": "A failed case: which case, which step, and why."
|
|
711
|
+
},
|
|
712
|
+
{
|
|
713
|
+
"id": "sqlite.sqlite.G9ContractReport",
|
|
714
|
+
"export": "G9ContractReport",
|
|
715
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
716
|
+
"kind": "interface",
|
|
717
|
+
"signature": "G9ContractReport",
|
|
718
|
+
"summary": "Outcome of `runContractSuite`. A runner that cannot execute reports `blocked-by-runner` itself, never pass."
|
|
719
|
+
},
|
|
720
|
+
{
|
|
721
|
+
"id": "sqlite.sqlite.G9ContractRunOptions",
|
|
722
|
+
"export": "G9ContractRunOptions",
|
|
723
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
724
|
+
"kind": "interface",
|
|
725
|
+
"signature": "G9ContractRunOptions",
|
|
726
|
+
"summary": "Options of a contract run against one driver."
|
|
727
|
+
},
|
|
728
|
+
{
|
|
729
|
+
"id": "sqlite.sqlite.G9ContractStatement",
|
|
730
|
+
"export": "G9ContractStatement",
|
|
731
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
732
|
+
"kind": "interface",
|
|
733
|
+
"signature": "G9ContractStatement",
|
|
734
|
+
"summary": "One statement of a contract step."
|
|
735
|
+
},
|
|
736
|
+
{
|
|
737
|
+
"id": "sqlite.sqlite.G9ContractStep",
|
|
738
|
+
"export": "G9ContractStep",
|
|
739
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
740
|
+
"kind": "interface",
|
|
741
|
+
"signature": "G9ContractStep",
|
|
742
|
+
"summary": "One step of a case. Exactly one of `run`, `open`, `begin`, `commit`, `rollback`, `close` is set."
|
|
743
|
+
},
|
|
744
|
+
{
|
|
745
|
+
"id": "sqlite.sqlite.G9ContractValue",
|
|
746
|
+
"export": "G9ContractValue",
|
|
747
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
748
|
+
"kind": "type",
|
|
749
|
+
"signature": "G9ContractValue",
|
|
750
|
+
"summary": "A value as written in `cases.json`."
|
|
751
|
+
},
|
|
752
|
+
{
|
|
753
|
+
"id": "sqlite.sqlite.G9CurrentUserProvider",
|
|
754
|
+
"export": "G9CurrentUserProvider",
|
|
755
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
756
|
+
"kind": "interface",
|
|
757
|
+
"signature": "G9CurrentUserProvider",
|
|
758
|
+
"summary": "Supplies the current user id for audit columns (MAUI `IG9CurrentUserProvider`), read at write time. `null` is a legitimate answer: existing user columns are kept rather than overwritten with nothing."
|
|
759
|
+
},
|
|
760
|
+
{
|
|
761
|
+
"id": "sqlite.sqlite.G9DatabaseLocator",
|
|
762
|
+
"export": "G9DatabaseLocator",
|
|
763
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
764
|
+
"kind": "interface",
|
|
765
|
+
"signature": "G9DatabaseLocator",
|
|
766
|
+
"summary": "Decides which database file is open and says when the answer changes (MAUI `IG9SqliteDatabaseLocator`). Read on every connection acquisition, so it must be cheap; returning a different path closes the old connection, resets every cache and opens the new file."
|
|
767
|
+
},
|
|
768
|
+
{
|
|
769
|
+
"id": "sqlite.sqlite.G9DateTimeWriteProfile",
|
|
770
|
+
"export": "G9DateTimeWriteProfile",
|
|
771
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
772
|
+
"kind": "type",
|
|
773
|
+
"signature": "G9DateTimeWriteProfile",
|
|
774
|
+
"summary": "How a `G9LocalDateTime` is written as text. - `provider`: the MAUI connection provider's `yyyy-MM-dd HH:mm:ss.FFFFFFF` (space; trailing fraction zeros and an all-zero fraction omitted). The default. - `sync`: G9SyncData's `yyyy-MM-dd'T'HH:mm:ss.fffffff` (T; always seven digits)."
|
|
775
|
+
},
|
|
776
|
+
{
|
|
777
|
+
"id": "sqlite.sqlite.g9DefaultCodecContext",
|
|
778
|
+
"export": "g9DefaultCodecContext",
|
|
779
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
780
|
+
"kind": "constant",
|
|
781
|
+
"signature": "G9CodecContext",
|
|
782
|
+
"summary": "The codec context of a default database: lowercase GUIDs, the provider date-time profile."
|
|
783
|
+
},
|
|
784
|
+
{
|
|
785
|
+
"id": "sqlite.sqlite.G9DeleteAccessor",
|
|
786
|
+
"export": "G9DeleteAccessor",
|
|
787
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
788
|
+
"kind": "class",
|
|
789
|
+
"signature": "typeof G9DeleteAccessor",
|
|
790
|
+
"summary": "MAUI `ISqliteDeleteAccessor<T>`. On a soft-delete entity every delete is an update of the flag unless `hard`."
|
|
791
|
+
},
|
|
792
|
+
{
|
|
793
|
+
"id": "sqlite.sqlite.G9DeleteBuilder",
|
|
794
|
+
"export": "G9DeleteBuilder",
|
|
795
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
796
|
+
"kind": "class",
|
|
797
|
+
"signature": "typeof G9DeleteBuilder",
|
|
798
|
+
"summary": "MAUI `SqliteDeleteQueryBuilder<T>`."
|
|
799
|
+
},
|
|
800
|
+
{
|
|
801
|
+
"id": "sqlite.sqlite.G9DeleteOptions",
|
|
802
|
+
"export": "G9DeleteOptions",
|
|
803
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
804
|
+
"kind": "interface",
|
|
805
|
+
"signature": "G9DeleteOptions",
|
|
806
|
+
"summary": "Delete options: `hard` deletes even on a soft-delete entity."
|
|
807
|
+
},
|
|
808
|
+
{
|
|
809
|
+
"id": "sqlite.sqlite.G9DriverCapabilities",
|
|
810
|
+
"export": "G9DriverCapabilities",
|
|
811
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
812
|
+
"kind": "interface",
|
|
813
|
+
"signature": "G9DriverCapabilities",
|
|
814
|
+
"summary": "What a driver supports (negotiated once per database)."
|
|
815
|
+
},
|
|
816
|
+
{
|
|
817
|
+
"id": "sqlite.sqlite.G9DriverStatement",
|
|
818
|
+
"export": "G9DriverStatement",
|
|
819
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
820
|
+
"kind": "interface",
|
|
821
|
+
"signature": "G9DriverStatement",
|
|
822
|
+
"summary": "One statement of a batch: SQL with `?` placeholders and its positional parameters."
|
|
823
|
+
},
|
|
824
|
+
{
|
|
825
|
+
"id": "sqlite.sqlite.G9Durability",
|
|
826
|
+
"export": "G9Durability",
|
|
827
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
828
|
+
"kind": "type",
|
|
829
|
+
"signature": "G9Durability",
|
|
830
|
+
"summary": "Durability of committed writes (D13): `full` (default) survives power loss; `normal` may lose the last commits."
|
|
831
|
+
},
|
|
832
|
+
{
|
|
833
|
+
"id": "sqlite.sqlite.G9EntityBuilder",
|
|
834
|
+
"export": "G9EntityBuilder",
|
|
835
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
836
|
+
"kind": "class",
|
|
837
|
+
"signature": "typeof G9EntityBuilder",
|
|
838
|
+
"summary": "MAUI `G9EntityBuilder<T>`: configures one entity's descriptor. Conventions (a GUID `id`, the five audit columns) apply first; builder calls override them."
|
|
839
|
+
},
|
|
840
|
+
{
|
|
841
|
+
"id": "sqlite.sqlite.G9EntityColumn",
|
|
842
|
+
"export": "G9EntityColumn",
|
|
843
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
844
|
+
"kind": "interface",
|
|
845
|
+
"signature": "G9EntityColumn",
|
|
846
|
+
"summary": "One column as an entity knows it: the property, its stored name and its spec."
|
|
847
|
+
},
|
|
848
|
+
{
|
|
849
|
+
"id": "sqlite.sqlite.G9EntityDescriptor",
|
|
850
|
+
"export": "G9EntityDescriptor",
|
|
851
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
852
|
+
"kind": "interface",
|
|
853
|
+
"signature": "G9EntityDescriptor<C>",
|
|
854
|
+
"summary": "Everything the library knows about one entity, frozen at definition (MAUI `G9EntityDescriptor`). Every later decision reads it: id normalisation, codecs, audit, soft delete, filters, conflicts, cache, indexes."
|
|
855
|
+
},
|
|
856
|
+
{
|
|
857
|
+
"id": "sqlite.sqlite.G9Expr",
|
|
858
|
+
"export": "G9Expr",
|
|
859
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
860
|
+
"kind": "type",
|
|
861
|
+
"signature": "G9Expr",
|
|
862
|
+
"summary": "A SQL expression tree node. Built with the operators below; compiled by the query compiler."
|
|
863
|
+
},
|
|
864
|
+
{
|
|
865
|
+
"id": "sqlite.sqlite.G9FunctionName",
|
|
866
|
+
"export": "G9FunctionName",
|
|
867
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
868
|
+
"kind": "type",
|
|
869
|
+
"signature": "G9FunctionName",
|
|
870
|
+
"summary": "The SQL functions the query builder can emit."
|
|
871
|
+
},
|
|
872
|
+
{
|
|
873
|
+
"id": "sqlite.sqlite.G9IdCase",
|
|
874
|
+
"export": "G9IdCase",
|
|
875
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
876
|
+
"kind": "enum",
|
|
877
|
+
"signature": "G9IdCase",
|
|
878
|
+
"summary": "Canonical casing for GUID strings the library writes (MAUI `G9IdCase`, ADR-0018). Lower is the default and matches `Guid.ToString()`. Choose once, before the first release: rows already written keep their casing (harmless in SQL, every id column is `COLLATE NOCASE`), but anything that derived a file path or preference key from a normalised id would be orphaned."
|
|
879
|
+
},
|
|
880
|
+
{
|
|
881
|
+
"id": "sqlite.sqlite.G9IndexDescriptor",
|
|
882
|
+
"export": "G9IndexDescriptor",
|
|
883
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
884
|
+
"kind": "interface",
|
|
885
|
+
"signature": "G9IndexDescriptor",
|
|
886
|
+
"summary": "MAUI `G9IndexDescriptor` (`Properties`, `IsUnique`) plus name, order, collation and a partial predicate."
|
|
887
|
+
},
|
|
888
|
+
{
|
|
889
|
+
"id": "sqlite.sqlite.G9IndexPart",
|
|
890
|
+
"export": "G9IndexPart",
|
|
891
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
892
|
+
"kind": "interface",
|
|
893
|
+
"signature": "G9IndexPart",
|
|
894
|
+
"summary": "One part of an index: a property, its direction and optional collation."
|
|
895
|
+
},
|
|
896
|
+
{
|
|
897
|
+
"id": "sqlite.sqlite.G9Initializer",
|
|
898
|
+
"export": "G9Initializer",
|
|
899
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
900
|
+
"kind": "interface",
|
|
901
|
+
"signature": "G9Initializer",
|
|
902
|
+
"summary": "Runs after successful migrations (MAUI `IG9SqliteInitializer`). `once` is recorded; `everyOpen` runs each open."
|
|
903
|
+
},
|
|
904
|
+
{
|
|
905
|
+
"id": "sqlite.sqlite.G9InputValue",
|
|
906
|
+
"export": "G9InputValue",
|
|
907
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
908
|
+
"kind": "type",
|
|
909
|
+
"signature": "G9InputValue<T>",
|
|
910
|
+
"summary": "What a write or a predicate accepts for a column of model type `T`: an int64 column also takes a decimal string or a safe integer (the codec validates and canonicalises it); every other type is itself."
|
|
911
|
+
},
|
|
912
|
+
{
|
|
913
|
+
"id": "sqlite.sqlite.G9InsertAccessor",
|
|
914
|
+
"export": "G9InsertAccessor",
|
|
915
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
916
|
+
"kind": "class",
|
|
917
|
+
"signature": "typeof G9InsertAccessor",
|
|
918
|
+
"summary": "MAUI `ISqliteInsertAccessor<T>`. Rows are prepared in place (ids, audit), as MAUI mutated the entity."
|
|
919
|
+
},
|
|
920
|
+
{
|
|
921
|
+
"id": "sqlite.sqlite.G9InsertOptions",
|
|
922
|
+
"export": "G9InsertOptions",
|
|
923
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
924
|
+
"kind": "interface",
|
|
925
|
+
"signature": "G9InsertOptions",
|
|
926
|
+
"summary": "Insert options: conflict policy (default the entity's, MAUI `OnConflict`)."
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
"id": "sqlite.sqlite.G9InsertRow",
|
|
930
|
+
"export": "G9InsertRow",
|
|
931
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
932
|
+
"kind": "type",
|
|
933
|
+
"signature": "G9InsertRow<E>",
|
|
934
|
+
"summary": "Insert-input type of an entity descriptor."
|
|
935
|
+
},
|
|
936
|
+
{
|
|
937
|
+
"id": "sqlite.sqlite.G9InsertRowOf",
|
|
938
|
+
"export": "G9InsertRowOf",
|
|
939
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
940
|
+
"kind": "type",
|
|
941
|
+
"signature": "G9InsertRowOf<C>",
|
|
942
|
+
"summary": "What insert accepts: nullable and library-filled columns may be omitted."
|
|
943
|
+
},
|
|
944
|
+
{
|
|
945
|
+
"id": "sqlite.sqlite.G9Int64",
|
|
946
|
+
"export": "G9Int64",
|
|
947
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
948
|
+
"kind": "type",
|
|
949
|
+
"signature": "G9Int64",
|
|
950
|
+
"summary": "Canonical signed 64-bit integer as a decimal string: `\"-9223372036854775808\"` … `\"9223372036854775807\"`, no plus sign, no leading zeros, `\"0\"` for zero (plan/specs/05-Persistence.md §3). Lynx has no guaranteed `BigInt`, so a value outside ±(2^53 − 1) never passes through a `number`: it travels as this string end to end."
|
|
951
|
+
},
|
|
952
|
+
{
|
|
953
|
+
"id": "sqlite.sqlite.G9Int64Tag",
|
|
954
|
+
"export": "G9Int64Tag",
|
|
955
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
956
|
+
"kind": "interface",
|
|
957
|
+
"signature": "G9Int64Tag",
|
|
958
|
+
"summary": "An int64 outside ±(2^53 − 1), tagged so it is never mistaken for text."
|
|
959
|
+
},
|
|
960
|
+
{
|
|
961
|
+
"id": "sqlite.sqlite.G9LocalDateTime",
|
|
962
|
+
"export": "G9LocalDateTime",
|
|
963
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
964
|
+
"kind": "interface",
|
|
965
|
+
"signature": "G9LocalDateTime",
|
|
966
|
+
"summary": "A calendar date and wall-clock time with .NET `DateTime` precision (100 ns ticks), no time zone and no offset: the shape MAUI stored in TEXT columns (plan/specs/05-Persistence.md §2). Never converted through `Date` unless asked, so no precision and no zone is invented."
|
|
967
|
+
},
|
|
968
|
+
{
|
|
969
|
+
"id": "sqlite.sqlite.G9Migration",
|
|
970
|
+
"export": "G9Migration",
|
|
971
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
972
|
+
"kind": "interface",
|
|
973
|
+
"signature": "G9Migration",
|
|
974
|
+
"summary": "One ordered schema change (MAUI `IG9SqliteMigration` and the legacy `ISqliteMigration`; one runner survives). `version` is explicit; gaps are fine; duplicates are rejected when the database is created. Applied versions are recorded with a checksum in `g9lynx_schema_history`; a changed checksum of an applied migration fails the open."
|
|
975
|
+
},
|
|
976
|
+
{
|
|
977
|
+
"id": "sqlite.sqlite.G9MigrationContext",
|
|
978
|
+
"export": "G9MigrationContext",
|
|
979
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
980
|
+
"kind": "interface",
|
|
981
|
+
"signature": "G9MigrationContext",
|
|
982
|
+
"summary": "What a migration or initializer works with (MAUI `IG9SqliteMigrationContext`), inside its transaction."
|
|
983
|
+
},
|
|
984
|
+
{
|
|
985
|
+
"id": "sqlite.sqlite.g9NoCurrentUser",
|
|
986
|
+
"export": "g9NoCurrentUser",
|
|
987
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
988
|
+
"kind": "constant",
|
|
989
|
+
"signature": "G9CurrentUserProvider",
|
|
990
|
+
"summary": "MAUI `G9NoCurrentUser`: nobody. Audit user columns keep what the row carried."
|
|
991
|
+
},
|
|
992
|
+
{
|
|
993
|
+
"id": "sqlite.sqlite.G9OpenOptions",
|
|
994
|
+
"export": "G9OpenOptions",
|
|
995
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
996
|
+
"kind": "interface",
|
|
997
|
+
"signature": "G9OpenOptions",
|
|
998
|
+
"summary": "How a driver opens a database session."
|
|
999
|
+
},
|
|
1000
|
+
{
|
|
1001
|
+
"id": "sqlite.sqlite.G9Operand",
|
|
1002
|
+
"export": "G9Operand",
|
|
1003
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1004
|
+
"kind": "type",
|
|
1005
|
+
"signature": "G9Operand<T>",
|
|
1006
|
+
"summary": "Anything an operator accepts: an expression, a column, or a plain value bound as a parameter."
|
|
1007
|
+
},
|
|
1008
|
+
{
|
|
1009
|
+
"id": "sqlite.sqlite.G9PerUserDatabaseLocator",
|
|
1010
|
+
"export": "G9PerUserDatabaseLocator",
|
|
1011
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1012
|
+
"kind": "interface",
|
|
1013
|
+
"signature": "G9PerUserDatabaseLocator",
|
|
1014
|
+
"summary": "A per-user locator (MAUI `G9PerUserDatabaseLocator`) with its `notifyUserChanged`."
|
|
1015
|
+
},
|
|
1016
|
+
{
|
|
1017
|
+
"id": "sqlite.sqlite.G9Predicate",
|
|
1018
|
+
"export": "G9Predicate",
|
|
1019
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1020
|
+
"kind": "type",
|
|
1021
|
+
"signature": "G9Expr",
|
|
1022
|
+
"summary": "A boolean-valued expression (a predicate)."
|
|
1023
|
+
},
|
|
1024
|
+
{
|
|
1025
|
+
"id": "sqlite.sqlite.G9Projection",
|
|
1026
|
+
"export": "G9Projection",
|
|
1027
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1028
|
+
"kind": "type",
|
|
1029
|
+
"signature": "G9Projection<P>",
|
|
1030
|
+
"summary": "Row type of a projection: a record of columns/expressions maps key by key; a column or list is keyed by name."
|
|
1031
|
+
},
|
|
1032
|
+
{
|
|
1033
|
+
"id": "sqlite.sqlite.G9QueryScope",
|
|
1034
|
+
"export": "G9QueryScope",
|
|
1035
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1036
|
+
"kind": "interface",
|
|
1037
|
+
"signature": "G9QueryScope",
|
|
1038
|
+
"summary": "One entity occurrence in a query (the root table or a join)."
|
|
1039
|
+
},
|
|
1040
|
+
{
|
|
1041
|
+
"id": "sqlite.sqlite.G9RefsOf",
|
|
1042
|
+
"export": "G9RefsOf",
|
|
1043
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1044
|
+
"kind": "type",
|
|
1045
|
+
"signature": "G9RefsOf<E>",
|
|
1046
|
+
"summary": "Column refs of an entity descriptor."
|
|
1047
|
+
},
|
|
1048
|
+
{
|
|
1049
|
+
"id": "sqlite.sqlite.G9RepoScope",
|
|
1050
|
+
"export": "G9RepoScope",
|
|
1051
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1052
|
+
"kind": "interface",
|
|
1053
|
+
"signature": "G9RepoScope",
|
|
1054
|
+
"summary": ""
|
|
1055
|
+
},
|
|
1056
|
+
{
|
|
1057
|
+
"id": "sqlite.sqlite.G9Repository",
|
|
1058
|
+
"export": "G9Repository",
|
|
1059
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1060
|
+
"kind": "class",
|
|
1061
|
+
"signature": "typeof G9Repository",
|
|
1062
|
+
"summary": "The repository of one entity (MAUI `SqliteRepository<T>` with its `Select`, `Insert`, `Update`, `Delete` and `Table` accessors). Every managed path applies the entity descriptor: GUID normalisation, codecs, audit, soft delete, always-filter, write conditions, conflict policy, caches."
|
|
1063
|
+
},
|
|
1064
|
+
{
|
|
1065
|
+
"id": "sqlite.sqlite.G9ResolvedSqliteOptions",
|
|
1066
|
+
"export": "G9ResolvedSqliteOptions",
|
|
1067
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1068
|
+
"kind": "interface",
|
|
1069
|
+
"signature": "G9ResolvedSqliteOptions",
|
|
1070
|
+
"summary": "Resolved, frozen options."
|
|
1071
|
+
},
|
|
1072
|
+
{
|
|
1073
|
+
"id": "sqlite.sqlite.G9ResultShape",
|
|
1074
|
+
"export": "G9ResultShape",
|
|
1075
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1076
|
+
"kind": "type",
|
|
1077
|
+
"signature": "G9ResultShape",
|
|
1078
|
+
"summary": "How the rows of a built SELECT decode."
|
|
1079
|
+
},
|
|
1080
|
+
{
|
|
1081
|
+
"id": "sqlite.sqlite.G9Row",
|
|
1082
|
+
"export": "G9Row",
|
|
1083
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1084
|
+
"kind": "type",
|
|
1085
|
+
"signature": "G9Row<E>",
|
|
1086
|
+
"summary": "Row type of an entity descriptor."
|
|
1087
|
+
},
|
|
1088
|
+
{
|
|
1089
|
+
"id": "sqlite.sqlite.G9RowOf",
|
|
1090
|
+
"export": "G9RowOf",
|
|
1091
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1092
|
+
"kind": "type",
|
|
1093
|
+
"signature": "G9RowOf<C>",
|
|
1094
|
+
"summary": "A full row of an entity: every column, nullable ones as `T \\| null`."
|
|
1095
|
+
},
|
|
1096
|
+
{
|
|
1097
|
+
"id": "sqlite.sqlite.G9RunOptions",
|
|
1098
|
+
"export": "G9RunOptions",
|
|
1099
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1100
|
+
"kind": "interface",
|
|
1101
|
+
"signature": "G9RunOptions",
|
|
1102
|
+
"summary": "Options of one driver batch: transaction, cancellation, row cap and atomicity."
|
|
1103
|
+
},
|
|
1104
|
+
{
|
|
1105
|
+
"id": "sqlite.sqlite.G9SelectAccessor",
|
|
1106
|
+
"export": "G9SelectAccessor",
|
|
1107
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1108
|
+
"kind": "class",
|
|
1109
|
+
"signature": "typeof G9SelectAccessor",
|
|
1110
|
+
"summary": "MAUI `ISqliteSelectAccessor<T>`."
|
|
1111
|
+
},
|
|
1112
|
+
{
|
|
1113
|
+
"id": "sqlite.sqlite.G9SelectBuilder",
|
|
1114
|
+
"export": "G9SelectBuilder",
|
|
1115
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1116
|
+
"kind": "class",
|
|
1117
|
+
"signature": "typeof G9SelectBuilder",
|
|
1118
|
+
"summary": "MAUI `SqliteSelectQueryBuilder<T>` (+ the shared `SqliteQueryBuilder<T>` SELECT surface)."
|
|
1119
|
+
},
|
|
1120
|
+
{
|
|
1121
|
+
"id": "sqlite.sqlite.G9SessionToken",
|
|
1122
|
+
"export": "G9SessionToken",
|
|
1123
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1124
|
+
"kind": "type",
|
|
1125
|
+
"signature": "G9SessionToken",
|
|
1126
|
+
"summary": "Opaque session handle; invalid after `close` (and after a user switch the session layer performs)."
|
|
1127
|
+
},
|
|
1128
|
+
{
|
|
1129
|
+
"id": "sqlite.sqlite.G9SoftDeleteDescriptor",
|
|
1130
|
+
"export": "G9SoftDeleteDescriptor",
|
|
1131
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1132
|
+
"kind": "interface",
|
|
1133
|
+
"signature": "G9SoftDeleteDescriptor",
|
|
1134
|
+
"summary": "MAUI `SoftDeleteProperty`, plus optional deletion audit properties."
|
|
1135
|
+
},
|
|
1136
|
+
{
|
|
1137
|
+
"id": "sqlite.sqlite.G9Sql",
|
|
1138
|
+
"export": "G9Sql",
|
|
1139
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1140
|
+
"kind": "constant",
|
|
1141
|
+
"signature": "{ readonly select: <E extends AnyEntity>(entity: E) => G9SelectBuilder<E, G9Row<E>>; readonly update: <E extends AnyEntity>(entity: E) => G9UpdateBuilder<E>; readonly delete: <E extends AnyEntity>(entity: E) => G9DeleteBuilder<E>; readonly tableName: (entity: AnyEntity) => string; }",
|
|
1142
|
+
"summary": "MAUI `SqliteQueryFactory`: starts a builder for an entity, usable without a database (build the statement, execute it elsewhere). Repositories return the same builders from `compose()`."
|
|
1143
|
+
},
|
|
1144
|
+
{
|
|
1145
|
+
"id": "sqlite.sqlite.G9SqlFragment",
|
|
1146
|
+
"export": "G9SqlFragment",
|
|
1147
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1148
|
+
"kind": "interface",
|
|
1149
|
+
"signature": "G9SqlFragment",
|
|
1150
|
+
"summary": "A compiled piece of SQL with its positional parameters, in placeholder order."
|
|
1151
|
+
},
|
|
1152
|
+
{
|
|
1153
|
+
"id": "sqlite.sqlite.G9Sqlite",
|
|
1154
|
+
"export": "G9Sqlite",
|
|
1155
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1156
|
+
"kind": "class",
|
|
1157
|
+
"signature": "typeof G9Sqlite",
|
|
1158
|
+
"summary": "The database facade returned by `createG9Sqlite` (MAUI `AddG9Sqlite` + `G9SqliteConnectionProvider` + `SqliteRepositoryCacheRegistry`)."
|
|
1159
|
+
},
|
|
1160
|
+
{
|
|
1161
|
+
"id": "sqlite.sqlite.G9SqliteDriver",
|
|
1162
|
+
"export": "G9SqliteDriver",
|
|
1163
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1164
|
+
"kind": "interface",
|
|
1165
|
+
"signature": "G9SqliteDriver",
|
|
1166
|
+
"summary": "The platform boundary (plan/specs/05-Persistence.md §3): native (Android/iOS), Lynxtron (desktop) and the Node reference driver implement it; `cases.json` is its contract. One `run` = one bridge round trip for N statements."
|
|
1167
|
+
},
|
|
1168
|
+
{
|
|
1169
|
+
"id": "sqlite.sqlite.G9SqliteError",
|
|
1170
|
+
"export": "G9SqliteError",
|
|
1171
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1172
|
+
"kind": "class",
|
|
1173
|
+
"signature": "typeof G9SqliteError",
|
|
1174
|
+
"summary": "Every failure of `@g9tm/lynxcontrols-sqlite` and its drivers."
|
|
1175
|
+
},
|
|
1176
|
+
{
|
|
1177
|
+
"id": "sqlite.sqlite.G9SqliteErrorCode",
|
|
1178
|
+
"export": "G9SqliteErrorCode",
|
|
1179
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1180
|
+
"kind": "type",
|
|
1181
|
+
"signature": "G9SqliteErrorCode",
|
|
1182
|
+
"summary": "Why a SQLite operation failed (plan/specs/05-Persistence.md §3). Stable; switch on it."
|
|
1183
|
+
},
|
|
1184
|
+
{
|
|
1185
|
+
"id": "sqlite.sqlite.G9SqliteErrorDetails",
|
|
1186
|
+
"export": "G9SqliteErrorDetails",
|
|
1187
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1188
|
+
"kind": "interface",
|
|
1189
|
+
"signature": "G9SqliteErrorDetails",
|
|
1190
|
+
"summary": "Extra facts about a `G9SqliteError`."
|
|
1191
|
+
},
|
|
1192
|
+
{
|
|
1193
|
+
"id": "sqlite.sqlite.G9SqliteInterceptor",
|
|
1194
|
+
"export": "G9SqliteInterceptor",
|
|
1195
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1196
|
+
"kind": "interface",
|
|
1197
|
+
"signature": "G9SqliteInterceptor",
|
|
1198
|
+
"summary": "Hooks into writes (MAUI `IG9SqliteInterceptor`, base class `G9SqliteInterceptor`): every member is optional, so an interceptor implements only what it needs."
|
|
1199
|
+
},
|
|
1200
|
+
{
|
|
1201
|
+
"id": "sqlite.sqlite.G9SqliteOptions",
|
|
1202
|
+
"export": "G9SqliteOptions",
|
|
1203
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1204
|
+
"kind": "interface",
|
|
1205
|
+
"signature": "G9SqliteOptions",
|
|
1206
|
+
"summary": "Options of `createG9Sqlite` (MAUI `G9SqliteOptions` / `AddG9Sqlite` builder)."
|
|
1207
|
+
},
|
|
1208
|
+
{
|
|
1209
|
+
"id": "sqlite.sqlite.G9SqliteScope",
|
|
1210
|
+
"export": "G9SqliteScope",
|
|
1211
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1212
|
+
"kind": "class",
|
|
1213
|
+
"signature": "typeof G9SqliteScope",
|
|
1214
|
+
"summary": "Where work runs: the database (each call its own atomic unit) or inside a transaction (every call joins it). Both `G9Sqlite` and transaction scopes have this surface."
|
|
1215
|
+
},
|
|
1216
|
+
{
|
|
1217
|
+
"id": "sqlite.sqlite.G9SqliteTransaction",
|
|
1218
|
+
"export": "G9SqliteTransaction",
|
|
1219
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1220
|
+
"kind": "class",
|
|
1221
|
+
"signature": "typeof G9SqliteTransaction",
|
|
1222
|
+
"summary": "An explicit transaction (MAUI `IG9SqliteTransaction`). Holds the connection until finished."
|
|
1223
|
+
},
|
|
1224
|
+
{
|
|
1225
|
+
"id": "sqlite.sqlite.G9SqlResult",
|
|
1226
|
+
"export": "G9SqlResult",
|
|
1227
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1228
|
+
"kind": "interface",
|
|
1229
|
+
"signature": "G9SqlResult",
|
|
1230
|
+
"summary": "The result of one statement (plan/specs/05-Persistence.md §3)."
|
|
1231
|
+
},
|
|
1232
|
+
{
|
|
1233
|
+
"id": "sqlite.sqlite.G9SqlStatement",
|
|
1234
|
+
"export": "G9SqlStatement",
|
|
1235
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1236
|
+
"kind": "interface",
|
|
1237
|
+
"signature": "G9SqlStatement",
|
|
1238
|
+
"summary": "A built statement: SQL with `?` placeholders and its parameters (MAUI `SqlStatement`)."
|
|
1239
|
+
},
|
|
1240
|
+
{
|
|
1241
|
+
"id": "sqlite.sqlite.G9SqlType",
|
|
1242
|
+
"export": "G9SqlType",
|
|
1243
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1244
|
+
"kind": "type",
|
|
1245
|
+
"signature": "G9SqlType",
|
|
1246
|
+
"summary": "SQLite storage class a codec declares in DDL (`CREATE TABLE` affinity)."
|
|
1247
|
+
},
|
|
1248
|
+
{
|
|
1249
|
+
"id": "sqlite.sqlite.G9SqlValue",
|
|
1250
|
+
"export": "G9SqlValue",
|
|
1251
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1252
|
+
"kind": "type",
|
|
1253
|
+
"signature": "G9SqlValue",
|
|
1254
|
+
"summary": "A value crossing the driver boundary (plan/specs/05-Persistence.md §3). Integers inside ±(2^53 − 1) are plain numbers (the fast path); larger ones are `G9Int64Tag`s. `null` is SQL NULL. A BLOB is an `ArrayBuffer` (empty ≠ NULL ≠ empty text)."
|
|
1255
|
+
},
|
|
1256
|
+
{
|
|
1257
|
+
"id": "sqlite.sqlite.G9TableAccessor",
|
|
1258
|
+
"export": "G9TableAccessor",
|
|
1259
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1260
|
+
"kind": "class",
|
|
1261
|
+
"signature": "typeof G9TableAccessor",
|
|
1262
|
+
"summary": "MAUI `ISqliteTableAccessor<T>`: raw access to the entity's table. Raw SQL is outside filters and soft delete."
|
|
1263
|
+
},
|
|
1264
|
+
{
|
|
1265
|
+
"id": "sqlite.sqlite.G9TransactionOptions",
|
|
1266
|
+
"export": "G9TransactionOptions",
|
|
1267
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1268
|
+
"kind": "interface",
|
|
1269
|
+
"signature": "G9TransactionOptions",
|
|
1270
|
+
"summary": "Options of a transaction."
|
|
1271
|
+
},
|
|
1272
|
+
{
|
|
1273
|
+
"id": "sqlite.sqlite.G9TxToken",
|
|
1274
|
+
"export": "G9TxToken",
|
|
1275
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1276
|
+
"kind": "type",
|
|
1277
|
+
"signature": "G9TxToken",
|
|
1278
|
+
"summary": "Opaque transaction handle; invalid after `commit`/`rollback`."
|
|
1279
|
+
},
|
|
1280
|
+
{
|
|
1281
|
+
"id": "sqlite.sqlite.g9UnixInvalidFileNameChars",
|
|
1282
|
+
"export": "g9UnixInvalidFileNameChars",
|
|
1283
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1284
|
+
"kind": "constant",
|
|
1285
|
+
"signature": "\"\\0/\"",
|
|
1286
|
+
"summary": "Characters .NET's `Path.GetInvalidFileNameChars()` reports on Android/iOS/macOS (MAUI's targets)."
|
|
1287
|
+
},
|
|
1288
|
+
{
|
|
1289
|
+
"id": "sqlite.sqlite.G9UpdateAccessor",
|
|
1290
|
+
"export": "G9UpdateAccessor",
|
|
1291
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1292
|
+
"kind": "class",
|
|
1293
|
+
"signature": "typeof G9UpdateAccessor",
|
|
1294
|
+
"summary": "MAUI `ISqliteUpdateAccessor<T>`."
|
|
1295
|
+
},
|
|
1296
|
+
{
|
|
1297
|
+
"id": "sqlite.sqlite.G9UpdateBuilder",
|
|
1298
|
+
"export": "G9UpdateBuilder",
|
|
1299
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1300
|
+
"kind": "class",
|
|
1301
|
+
"signature": "typeof G9UpdateBuilder",
|
|
1302
|
+
"summary": "MAUI `SqliteUpdateQueryBuilder<T>`."
|
|
1303
|
+
},
|
|
1304
|
+
{
|
|
1305
|
+
"id": "sqlite.sqlite.G9UpsertPolicy",
|
|
1306
|
+
"export": "G9UpsertPolicy",
|
|
1307
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1308
|
+
"kind": "interface",
|
|
1309
|
+
"signature": "G9UpsertPolicy",
|
|
1310
|
+
"summary": "An upsert conflict policy."
|
|
1311
|
+
},
|
|
1312
|
+
{
|
|
1313
|
+
"id": "sqlite.sqlite.G9ValueConverter",
|
|
1314
|
+
"export": "G9ValueConverter",
|
|
1315
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1316
|
+
"kind": "interface",
|
|
1317
|
+
"signature": "G9ValueConverter<TModel, TStore>",
|
|
1318
|
+
"summary": "MAUI `IG9ValueConverter<TModel, TStore>`: model ↔ store, layered over a store codec."
|
|
1319
|
+
},
|
|
1320
|
+
{
|
|
1321
|
+
"id": "sqlite.sqlite.g9WindowsInvalidFileNameChars",
|
|
1322
|
+
"export": "g9WindowsInvalidFileNameChars",
|
|
1323
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1324
|
+
"kind": "constant",
|
|
1325
|
+
"signature": "\"\\0/\\\\:*?\\\"<>|\"",
|
|
1326
|
+
"summary": "The Windows set (control characters are always removed too)."
|
|
1327
|
+
},
|
|
1328
|
+
{
|
|
1329
|
+
"id": "sqlite.sqlite.G9WriteContext",
|
|
1330
|
+
"export": "G9WriteContext",
|
|
1331
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1332
|
+
"kind": "interface",
|
|
1333
|
+
"signature": "G9WriteContext<Row>",
|
|
1334
|
+
"summary": "What an interceptor is told about a write (MAUI `G9WriteContext`)."
|
|
1335
|
+
},
|
|
1336
|
+
{
|
|
1337
|
+
"id": "sqlite.sqlite.G9WriteDecision",
|
|
1338
|
+
"export": "G9WriteDecision",
|
|
1339
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1340
|
+
"kind": "constant",
|
|
1341
|
+
"signature": "{ readonly allow: () => G9WriteDecision; readonly veto: (reason: string) => G9WriteDecision; }",
|
|
1342
|
+
"summary": "Whether a write proceeds, and why not (MAUI `G9WriteDecision`). A veto is an expected outcome, not a failure. MAUI `G9WriteDecision.Allow()` / `.Veto(reason)`."
|
|
1343
|
+
},
|
|
1344
|
+
{
|
|
1345
|
+
"id": "sqlite.sqlite.G9WriteKind",
|
|
1346
|
+
"export": "G9WriteKind",
|
|
1347
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1348
|
+
"kind": "enum",
|
|
1349
|
+
"signature": "G9WriteKind",
|
|
1350
|
+
"summary": "Which write is happening (MAUI `G9WriteKind`). Interceptors branch on it."
|
|
1351
|
+
},
|
|
1352
|
+
{
|
|
1353
|
+
"id": "sqlite.sqlite.G9WriteOptions",
|
|
1354
|
+
"export": "G9WriteOptions",
|
|
1355
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1356
|
+
"kind": "interface",
|
|
1357
|
+
"signature": "G9WriteOptions",
|
|
1358
|
+
"summary": "Per-call write options."
|
|
1359
|
+
},
|
|
1360
|
+
{
|
|
1361
|
+
"id": "sqlite.sqlite.G9WriteTransaction",
|
|
1362
|
+
"export": "G9WriteTransaction",
|
|
1363
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1364
|
+
"kind": "interface",
|
|
1365
|
+
"signature": "G9WriteTransaction",
|
|
1366
|
+
"summary": "The slice of a transaction an interceptor may use while a write is in flight."
|
|
1367
|
+
},
|
|
1368
|
+
{
|
|
1369
|
+
"id": "sqlite.sqlite.G9WriteVetoedError",
|
|
1370
|
+
"export": "G9WriteVetoedError",
|
|
1371
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1372
|
+
"kind": "class",
|
|
1373
|
+
"signature": "typeof G9WriteVetoedError",
|
|
1374
|
+
"summary": "Thrown to the caller when an interceptor vetoed (the whole atomic write rolled back)."
|
|
1375
|
+
},
|
|
1376
|
+
{
|
|
1377
|
+
"id": "sqlite.sqlite.gt",
|
|
1378
|
+
"export": "gt",
|
|
1379
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1380
|
+
"kind": "function",
|
|
1381
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1382
|
+
"summary": "SQL `>` (NULL never matches)."
|
|
1383
|
+
},
|
|
1384
|
+
{
|
|
1385
|
+
"id": "sqlite.sqlite.gte",
|
|
1386
|
+
"export": "gte",
|
|
1387
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1388
|
+
"kind": "function",
|
|
1389
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1390
|
+
"summary": "SQL `>=` (NULL never matches)."
|
|
1391
|
+
},
|
|
1392
|
+
{
|
|
1393
|
+
"id": "sqlite.sqlite.guid",
|
|
1394
|
+
"export": "guid",
|
|
1395
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1396
|
+
"kind": "function",
|
|
1397
|
+
"signature": "(): G9Column<string, false, false>",
|
|
1398
|
+
"summary": "GUID string column (normalised, `COLLATE NOCASE`), MAUI `[G9GuidId]` / `HasGuidId`."
|
|
1399
|
+
},
|
|
1400
|
+
{
|
|
1401
|
+
"id": "sqlite.sqlite.guidCodec",
|
|
1402
|
+
"export": "guidCodec",
|
|
1403
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1404
|
+
"kind": "constant",
|
|
1405
|
+
"signature": "G9Codec<string>",
|
|
1406
|
+
"summary": "A GUID string: normalised to the canonical `D` form in the database's id case on write (and in predicates); read back exactly as stored. Non-GUID text passes through trimmed, as MAUI did."
|
|
1407
|
+
},
|
|
1408
|
+
{
|
|
1409
|
+
"id": "sqlite.sqlite.guidId",
|
|
1410
|
+
"export": "guidId",
|
|
1411
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1412
|
+
"kind": "function",
|
|
1413
|
+
"signature": "(): G9Column<string, false, true>",
|
|
1414
|
+
"summary": "GUID primary key (MAUI's `Id`): normalised, `COLLATE NOCASE`, minted on insert when empty (so it is optional on insert)."
|
|
1415
|
+
},
|
|
1416
|
+
{
|
|
1417
|
+
"id": "sqlite.sqlite.hexToBytes",
|
|
1418
|
+
"export": "hexToBytes",
|
|
1419
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1420
|
+
"kind": "function",
|
|
1421
|
+
"signature": "(hex: string): ArrayBuffer",
|
|
1422
|
+
"summary": "Parses hex (any case, even length) into an `ArrayBuffer`."
|
|
1423
|
+
},
|
|
1424
|
+
{
|
|
1425
|
+
"id": "sqlite.sqlite.idEquals",
|
|
1426
|
+
"export": "idEquals",
|
|
1427
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1428
|
+
"kind": "function",
|
|
1429
|
+
"signature": "(left: string | null | undefined, right: string | null | undefined): boolean",
|
|
1430
|
+
"summary": "MAUI `G9IdComparer.Equals`: case-insensitive ordinal comparison of two ids (two nulls are equal). Faster than normalising both and the only correct comparison for GUID strings, which can arrive in any casing."
|
|
1431
|
+
},
|
|
1432
|
+
{
|
|
1433
|
+
"id": "sqlite.sqlite.idKey",
|
|
1434
|
+
"export": "idKey",
|
|
1435
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1436
|
+
"kind": "function",
|
|
1437
|
+
"signature": "(value: string | null | undefined): string",
|
|
1438
|
+
"summary": "MAUI `G9IdComparer.Ordinal` for JavaScript collections: a key that is equal for ids that `idEquals`. Use it for every id-keyed `Map`/`Set` (`map.set(idKey(row.id), row)`)."
|
|
1439
|
+
},
|
|
1440
|
+
{
|
|
1441
|
+
"id": "sqlite.sqlite.indexName",
|
|
1442
|
+
"export": "indexName",
|
|
1443
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1444
|
+
"kind": "function",
|
|
1445
|
+
"signature": "(entity: G9EntityDescriptor<any>, index: G9IndexDescriptor): string",
|
|
1446
|
+
"summary": "Name of a declared index (`IX_Table_A_B`, `UX_…` for unique) unless the declaration names it."
|
|
1447
|
+
},
|
|
1448
|
+
{
|
|
1449
|
+
"id": "sqlite.sqlite.inlinedSql",
|
|
1450
|
+
"export": "inlinedSql",
|
|
1451
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1452
|
+
"kind": "function",
|
|
1453
|
+
"signature": "(statement: G9SqlStatement): string",
|
|
1454
|
+
"summary": "MAUI `SqlStatement.InlinedSql`: the statement with literals inlined, for logs only."
|
|
1455
|
+
},
|
|
1456
|
+
{
|
|
1457
|
+
"id": "sqlite.sqlite.inlineSql",
|
|
1458
|
+
"export": "inlineSql",
|
|
1459
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1460
|
+
"kind": "function",
|
|
1461
|
+
"signature": "(sql: string, params: readonly G9SqlValue[]): string",
|
|
1462
|
+
"summary": "SQL text with parameters rendered as literals (MAUI `InlineSql`): diagnostics only, never execute it."
|
|
1463
|
+
},
|
|
1464
|
+
{
|
|
1465
|
+
"id": "sqlite.sqlite.inList",
|
|
1466
|
+
"export": "inList",
|
|
1467
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1468
|
+
"kind": "function",
|
|
1469
|
+
"signature": "<T>(operand: G9Operand<T>, values: Iterable<T | null>): G9Expr",
|
|
1470
|
+
"summary": "C# `list.Contains(x.Col)`: `col IN (?, …)`. An empty list matches nothing (`0 = 1`). A list containing `null` also matches NULL rows (`… OR col IS NULL`), the C# meaning. More values than the placeholder budget travel as one JSON parameter through `json_each` (MAUI, 16 000)."
|
|
1471
|
+
},
|
|
1472
|
+
{
|
|
1473
|
+
"id": "sqlite.sqlite.int",
|
|
1474
|
+
"export": "int",
|
|
1475
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1476
|
+
"kind": "function",
|
|
1477
|
+
"signature": "(): G9Column<number, false, false>",
|
|
1478
|
+
"summary": "INTEGER within ±(2^53 − 1)."
|
|
1479
|
+
},
|
|
1480
|
+
{
|
|
1481
|
+
"id": "sqlite.sqlite.int64",
|
|
1482
|
+
"export": "int64",
|
|
1483
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1484
|
+
"kind": "function",
|
|
1485
|
+
"signature": "(): G9Column<G9Int64, false, false>",
|
|
1486
|
+
"summary": "Lossless signed 64-bit INTEGER as a `G9Int64` decimal string."
|
|
1487
|
+
},
|
|
1488
|
+
{
|
|
1489
|
+
"id": "sqlite.sqlite.int64Codec",
|
|
1490
|
+
"export": "int64Codec",
|
|
1491
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1492
|
+
"kind": "constant",
|
|
1493
|
+
"signature": "G9Codec<G9Int64>",
|
|
1494
|
+
"summary": "Signed 64-bit INTEGER, lossless: the model value is a `G9Int64` decimal string."
|
|
1495
|
+
},
|
|
1496
|
+
{
|
|
1497
|
+
"id": "sqlite.sqlite.int64FromSqlValue",
|
|
1498
|
+
"export": "int64FromSqlValue",
|
|
1499
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1500
|
+
"kind": "function",
|
|
1501
|
+
"signature": "(value: G9SqlValue): G9Int64",
|
|
1502
|
+
"summary": "Reads an integer `G9SqlValue` as a canonical `G9Int64`. Throws `misuse` for anything that is not an integer (a REAL with a fraction, text, a BLOB)."
|
|
1503
|
+
},
|
|
1504
|
+
{
|
|
1505
|
+
"id": "sqlite.sqlite.int64ToNumber",
|
|
1506
|
+
"export": "int64ToNumber",
|
|
1507
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1508
|
+
"kind": "function",
|
|
1509
|
+
"signature": "(value: G9Int64): number",
|
|
1510
|
+
"summary": "The exact `number` for a safe int64; throws `misuse` when the value would lose precision."
|
|
1511
|
+
},
|
|
1512
|
+
{
|
|
1513
|
+
"id": "sqlite.sqlite.int64ToSqlValue",
|
|
1514
|
+
"export": "int64ToSqlValue",
|
|
1515
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1516
|
+
"kind": "function",
|
|
1517
|
+
"signature": "(value: string | number | G9Int64): number | G9Int64Tag",
|
|
1518
|
+
"summary": "The driver-boundary form of an int64: a plain number when safe, a tag otherwise. Accepts a canonical `G9Int64`, any decimal integer string, or a safe integer."
|
|
1519
|
+
},
|
|
1520
|
+
{
|
|
1521
|
+
"id": "sqlite.sqlite.intCodec",
|
|
1522
|
+
"export": "intCodec",
|
|
1523
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1524
|
+
"kind": "constant",
|
|
1525
|
+
"signature": "G9Codec<number>",
|
|
1526
|
+
"summary": "INTEGER within ±(2^53 − 1). Larger stored values fail loudly: declare the column `int64()`."
|
|
1527
|
+
},
|
|
1528
|
+
{
|
|
1529
|
+
"id": "sqlite.sqlite.isColumnRef",
|
|
1530
|
+
"export": "isColumnRef",
|
|
1531
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1532
|
+
"kind": "function",
|
|
1533
|
+
"signature": "(value: unknown): value is G9ColumnRef<unknown>",
|
|
1534
|
+
"summary": "`true` for a column reference."
|
|
1535
|
+
},
|
|
1536
|
+
{
|
|
1537
|
+
"id": "sqlite.sqlite.isDifferent",
|
|
1538
|
+
"export": "isDifferent",
|
|
1539
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1540
|
+
"kind": "function",
|
|
1541
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1542
|
+
"summary": "SQLite null-safe inequality `a IS NOT b`."
|
|
1543
|
+
},
|
|
1544
|
+
{
|
|
1545
|
+
"id": "sqlite.sqlite.isEmptyGuid",
|
|
1546
|
+
"export": "isEmptyGuid",
|
|
1547
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1548
|
+
"kind": "function",
|
|
1549
|
+
"signature": "(value: string | null | undefined): boolean",
|
|
1550
|
+
"summary": "`true` for the all-zero GUID, the placeholder MAUI refused as a merge key."
|
|
1551
|
+
},
|
|
1552
|
+
{
|
|
1553
|
+
"id": "sqlite.sqlite.isExpr",
|
|
1554
|
+
"export": "isExpr",
|
|
1555
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1556
|
+
"kind": "function",
|
|
1557
|
+
"signature": "(value: unknown): value is G9Expr",
|
|
1558
|
+
"summary": "`true` for a `G9Expr` node (as opposed to a plain value)."
|
|
1559
|
+
},
|
|
1560
|
+
{
|
|
1561
|
+
"id": "sqlite.sqlite.isG9SqliteError",
|
|
1562
|
+
"export": "isG9SqliteError",
|
|
1563
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1564
|
+
"kind": "function",
|
|
1565
|
+
"signature": "(error: unknown, ...codes: G9SqliteErrorCode[]): error is G9SqliteError",
|
|
1566
|
+
"summary": "`true` for a `G9SqliteError`, optionally of one of the given codes."
|
|
1567
|
+
},
|
|
1568
|
+
{
|
|
1569
|
+
"id": "sqlite.sqlite.isGuidText",
|
|
1570
|
+
"export": "isGuidText",
|
|
1571
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1572
|
+
"kind": "function",
|
|
1573
|
+
"signature": "(text: string): boolean",
|
|
1574
|
+
"summary": "`true` when `text` is a GUID in a form `parseGuidHex` accepts."
|
|
1575
|
+
},
|
|
1576
|
+
{
|
|
1577
|
+
"id": "sqlite.sqlite.isInt64",
|
|
1578
|
+
"export": "isInt64",
|
|
1579
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1580
|
+
"kind": "function",
|
|
1581
|
+
"signature": "(value: unknown): value is G9Int64",
|
|
1582
|
+
"summary": "`true` when `value` is a canonical `G9Int64` string (range included)."
|
|
1583
|
+
},
|
|
1584
|
+
{
|
|
1585
|
+
"id": "sqlite.sqlite.isInt64Tag",
|
|
1586
|
+
"export": "isInt64Tag",
|
|
1587
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1588
|
+
"kind": "function",
|
|
1589
|
+
"signature": "(value: unknown): value is G9Int64Tag",
|
|
1590
|
+
"summary": "`true` for a `G9Int64Tag`."
|
|
1591
|
+
},
|
|
1592
|
+
{
|
|
1593
|
+
"id": "sqlite.sqlite.isLegacyDateTimeText",
|
|
1594
|
+
"export": "isLegacyDateTimeText",
|
|
1595
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1596
|
+
"kind": "function",
|
|
1597
|
+
"signature": "(text: string): boolean",
|
|
1598
|
+
"summary": "`true` when `text` is a stored date/time `parseLegacyDateTime` accepts."
|
|
1599
|
+
},
|
|
1600
|
+
{
|
|
1601
|
+
"id": "sqlite.sqlite.isMutationSql",
|
|
1602
|
+
"export": "isMutationSql",
|
|
1603
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1604
|
+
"kind": "function",
|
|
1605
|
+
"signature": "(sql: string): boolean",
|
|
1606
|
+
"summary": "MAUI `ReadLeadingSqlKeyword` + `IsMutationSql`: comments skipped, INSERT/UPDATE/DELETE/REPLACE (and WITH)."
|
|
1607
|
+
},
|
|
1608
|
+
{
|
|
1609
|
+
"id": "sqlite.sqlite.isNotNull",
|
|
1610
|
+
"export": "isNotNull",
|
|
1611
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1612
|
+
"kind": "function",
|
|
1613
|
+
"signature": "(operand: unknown): G9Expr",
|
|
1614
|
+
"summary": "`col IS NOT NULL`."
|
|
1615
|
+
},
|
|
1616
|
+
{
|
|
1617
|
+
"id": "sqlite.sqlite.isNull",
|
|
1618
|
+
"export": "isNull",
|
|
1619
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1620
|
+
"kind": "function",
|
|
1621
|
+
"signature": "(operand: unknown): G9Expr",
|
|
1622
|
+
"summary": "`col IS NULL`."
|
|
1623
|
+
},
|
|
1624
|
+
{
|
|
1625
|
+
"id": "sqlite.sqlite.isNullOrEmpty",
|
|
1626
|
+
"export": "isNullOrEmpty",
|
|
1627
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1628
|
+
"kind": "function",
|
|
1629
|
+
"signature": "(operand: G9Operand<string>): G9Expr",
|
|
1630
|
+
"summary": "C# `string.IsNullOrEmpty(x.Code)`: `(col IS NULL OR col = '')`."
|
|
1631
|
+
},
|
|
1632
|
+
{
|
|
1633
|
+
"id": "sqlite.sqlite.isSafeInt64",
|
|
1634
|
+
"export": "isSafeInt64",
|
|
1635
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1636
|
+
"kind": "function",
|
|
1637
|
+
"signature": "(value: G9Int64): boolean",
|
|
1638
|
+
"summary": "`true` when the int64 lies within ±(2^53 − 1) and so converts to a `number` exactly."
|
|
1639
|
+
},
|
|
1640
|
+
{
|
|
1641
|
+
"id": "sqlite.sqlite.isSame",
|
|
1642
|
+
"export": "isSame",
|
|
1643
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1644
|
+
"kind": "function",
|
|
1645
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1646
|
+
"summary": "SQLite null-safe equality `a IS b` (NULL IS NULL is true)."
|
|
1647
|
+
},
|
|
1648
|
+
{
|
|
1649
|
+
"id": "sqlite.sqlite.isSqlValue",
|
|
1650
|
+
"export": "isSqlValue",
|
|
1651
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1652
|
+
"kind": "function",
|
|
1653
|
+
"signature": "(value: unknown): value is G9SqlValue",
|
|
1654
|
+
"summary": "`true` when `value` is a valid `G9SqlValue`. `NaN` is not (SQLite stores it as NULL, silently)."
|
|
1655
|
+
},
|
|
1656
|
+
{
|
|
1657
|
+
"id": "sqlite.sqlite.json",
|
|
1658
|
+
"export": "json",
|
|
1659
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1660
|
+
"kind": "function",
|
|
1661
|
+
"signature": "<T>(): G9Column<T, false, false>",
|
|
1662
|
+
"summary": "JSON value as TEXT."
|
|
1663
|
+
},
|
|
1664
|
+
{
|
|
1665
|
+
"id": "sqlite.sqlite.jsonCodec",
|
|
1666
|
+
"export": "jsonCodec",
|
|
1667
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1668
|
+
"kind": "function",
|
|
1669
|
+
"signature": "<T>(): G9Codec<T>",
|
|
1670
|
+
"summary": "Any JSON value stored as TEXT."
|
|
1671
|
+
},
|
|
1672
|
+
{
|
|
1673
|
+
"id": "sqlite.sqlite.latestMigrationVersion",
|
|
1674
|
+
"export": "latestMigrationVersion",
|
|
1675
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1676
|
+
"kind": "function",
|
|
1677
|
+
"signature": "(migrations: readonly G9Migration[]): number | null",
|
|
1678
|
+
"summary": "MAUI `SqliteMigrationRunner.GetLatestRegisteredVersion`: the highest registered version, or `null`."
|
|
1679
|
+
},
|
|
1680
|
+
{
|
|
1681
|
+
"id": "sqlite.sqlite.legacyDateTime",
|
|
1682
|
+
"export": "legacyDateTime",
|
|
1683
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1684
|
+
"kind": "function",
|
|
1685
|
+
"signature": "(profile?: G9DateTimeWriteProfile | undefined): G9Column<G9LocalDateTime, false, false>",
|
|
1686
|
+
"summary": "MAUI TEXT date/time (both separators, 7 fraction digits), optionally with a fixed write profile."
|
|
1687
|
+
},
|
|
1688
|
+
{
|
|
1689
|
+
"id": "sqlite.sqlite.legacyDateTimeCodec",
|
|
1690
|
+
"export": "legacyDateTimeCodec",
|
|
1691
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1692
|
+
"kind": "function",
|
|
1693
|
+
"signature": "(profile?: G9DateTimeWriteProfile | undefined): G9Codec<G9LocalDateTime>",
|
|
1694
|
+
"summary": "A MAUI-format TEXT date/time (both separators, 0–7 fraction digits) as `G9LocalDateTime`."
|
|
1695
|
+
},
|
|
1696
|
+
{
|
|
1697
|
+
"id": "sqlite.sqlite.length",
|
|
1698
|
+
"export": "length",
|
|
1699
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1700
|
+
"kind": "function",
|
|
1701
|
+
"signature": "(operand: unknown): G9Expr",
|
|
1702
|
+
"summary": "`LENGTH(col)`."
|
|
1703
|
+
},
|
|
1704
|
+
{
|
|
1705
|
+
"id": "sqlite.sqlite.like",
|
|
1706
|
+
"export": "like",
|
|
1707
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1708
|
+
"kind": "function",
|
|
1709
|
+
"signature": "(operand: G9Operand<string>, pattern: string): G9Expr",
|
|
1710
|
+
"summary": "Raw `LIKE` with a caller pattern (`%`/`_` are wildcards; no escape clause)."
|
|
1711
|
+
},
|
|
1712
|
+
{
|
|
1713
|
+
"id": "sqlite.sqlite.localDateTimeEquals",
|
|
1714
|
+
"export": "localDateTimeEquals",
|
|
1715
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1716
|
+
"kind": "function",
|
|
1717
|
+
"signature": "(a: G9LocalDateTime, b: G9LocalDateTime): boolean",
|
|
1718
|
+
"summary": "`true` when both values are the same instant of wall time (tick precision)."
|
|
1719
|
+
},
|
|
1720
|
+
{
|
|
1721
|
+
"id": "sqlite.sqlite.localDateTimeFromEpochMs",
|
|
1722
|
+
"export": "localDateTimeFromEpochMs",
|
|
1723
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1724
|
+
"kind": "function",
|
|
1725
|
+
"signature": "(epochMs: number, offsetMinutes?: number): G9LocalDateTime",
|
|
1726
|
+
"summary": "The wall-clock fields of an epoch-millisecond instant at a fixed UTC offset (default 0 = UTC, MAUI's `G9SystemClock`). Pure arithmetic: no `Date`, no `Intl`, no time-zone database."
|
|
1727
|
+
},
|
|
1728
|
+
{
|
|
1729
|
+
"id": "sqlite.sqlite.localDateTimeToEpochMs",
|
|
1730
|
+
"export": "localDateTimeToEpochMs",
|
|
1731
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1732
|
+
"kind": "function",
|
|
1733
|
+
"signature": "(value: G9LocalDateTime, offsetMinutes?: number): number",
|
|
1734
|
+
"summary": "The epoch milliseconds of a wall-clock value read at a fixed UTC offset (default UTC). Sub-millisecond ticks are truncated: use the value itself when 100 ns precision matters."
|
|
1735
|
+
},
|
|
1736
|
+
{
|
|
1737
|
+
"id": "sqlite.sqlite.localizedKey",
|
|
1738
|
+
"export": "localizedKey",
|
|
1739
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1740
|
+
"kind": "function",
|
|
1741
|
+
"signature": "(ref: G9ColumnRef<unknown>): string",
|
|
1742
|
+
"summary": "Key of a localized-column override."
|
|
1743
|
+
},
|
|
1744
|
+
{
|
|
1745
|
+
"id": "sqlite.sqlite.lower",
|
|
1746
|
+
"export": "lower",
|
|
1747
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1748
|
+
"kind": "function",
|
|
1749
|
+
"signature": "(operand: G9Operand<string>): G9Expr",
|
|
1750
|
+
"summary": "`LOWER(col)`."
|
|
1751
|
+
},
|
|
1752
|
+
{
|
|
1753
|
+
"id": "sqlite.sqlite.lt",
|
|
1754
|
+
"export": "lt",
|
|
1755
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1756
|
+
"kind": "function",
|
|
1757
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1758
|
+
"summary": "SQL `<` (NULL never matches)."
|
|
1759
|
+
},
|
|
1760
|
+
{
|
|
1761
|
+
"id": "sqlite.sqlite.lte",
|
|
1762
|
+
"export": "lte",
|
|
1763
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1764
|
+
"kind": "function",
|
|
1765
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1766
|
+
"summary": "SQL `<=` (NULL never matches)."
|
|
1767
|
+
},
|
|
1768
|
+
{
|
|
1769
|
+
"id": "sqlite.sqlite.max",
|
|
1770
|
+
"export": "max",
|
|
1771
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1772
|
+
"kind": "function",
|
|
1773
|
+
"signature": "(operand: unknown): G9Expr",
|
|
1774
|
+
"summary": "`MAX(col)`."
|
|
1775
|
+
},
|
|
1776
|
+
{
|
|
1777
|
+
"id": "sqlite.sqlite.min",
|
|
1778
|
+
"export": "min",
|
|
1779
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1780
|
+
"kind": "function",
|
|
1781
|
+
"signature": "(operand: unknown): G9Expr",
|
|
1782
|
+
"summary": "`MIN(col)`."
|
|
1783
|
+
},
|
|
1784
|
+
{
|
|
1785
|
+
"id": "sqlite.sqlite.mod",
|
|
1786
|
+
"export": "mod",
|
|
1787
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1788
|
+
"kind": "function",
|
|
1789
|
+
"signature": "(left: G9Operand<number>, right: G9Operand<number>): G9Expr",
|
|
1790
|
+
"summary": "Arithmetic `%` (parenthesised)."
|
|
1791
|
+
},
|
|
1792
|
+
{
|
|
1793
|
+
"id": "sqlite.sqlite.mul",
|
|
1794
|
+
"export": "mul",
|
|
1795
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1796
|
+
"kind": "function",
|
|
1797
|
+
"signature": "(left: G9Operand<number>, right: G9Operand<number>): G9Expr",
|
|
1798
|
+
"summary": "Arithmetic `*` (parenthesised)."
|
|
1799
|
+
},
|
|
1800
|
+
{
|
|
1801
|
+
"id": "sqlite.sqlite.ne",
|
|
1802
|
+
"export": "ne",
|
|
1803
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1804
|
+
"kind": "function",
|
|
1805
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
1806
|
+
"summary": "C# `!=`: `(col <> ? OR col IS NULL)` — rows whose column is NULL are kept, as C# would — or `col IS NOT NULL` for a null value. Two columns compare with plain `<>`."
|
|
1807
|
+
},
|
|
1808
|
+
{
|
|
1809
|
+
"id": "sqlite.sqlite.negate",
|
|
1810
|
+
"export": "negate",
|
|
1811
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1812
|
+
"kind": "function",
|
|
1813
|
+
"signature": "(operand: G9Operand<number>): G9Expr",
|
|
1814
|
+
"summary": "Unary minus `-(…)`."
|
|
1815
|
+
},
|
|
1816
|
+
{
|
|
1817
|
+
"id": "sqlite.sqlite.negateInt64",
|
|
1818
|
+
"export": "negateInt64",
|
|
1819
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1820
|
+
"kind": "function",
|
|
1821
|
+
"signature": "(a: G9Int64): G9Int64",
|
|
1822
|
+
"summary": "−a; throws `misuse` for `G9_INT64_MIN`, whose negation does not fit."
|
|
1823
|
+
},
|
|
1824
|
+
{
|
|
1825
|
+
"id": "sqlite.sqlite.newId",
|
|
1826
|
+
"export": "newId",
|
|
1827
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1828
|
+
"kind": "function",
|
|
1829
|
+
"signature": "(idCase?: G9IdCase, random?: () => Uint8Array<ArrayBufferLike>): string",
|
|
1830
|
+
"summary": "MAUI `CreateNewId()`: a random (version 4) GUID in canonical form."
|
|
1831
|
+
},
|
|
1832
|
+
{
|
|
1833
|
+
"id": "sqlite.sqlite.normalizeId",
|
|
1834
|
+
"export": "normalizeId",
|
|
1835
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1836
|
+
"kind": "function",
|
|
1837
|
+
"signature": "(value: string | null | undefined, idCase?: G9IdCase): string | null",
|
|
1838
|
+
"summary": "MAUI `NormalizeSqliteGuidId(string?)`: `null` for null/empty/whitespace; a GUID in any accepted form becomes its canonical `D` form in `idCase`; any other text is returned trimmed (ids that are not GUIDs pass through)."
|
|
1839
|
+
},
|
|
1840
|
+
{
|
|
1841
|
+
"id": "sqlite.sqlite.normalizeIdLike",
|
|
1842
|
+
"export": "normalizeIdLike",
|
|
1843
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1844
|
+
"kind": "function",
|
|
1845
|
+
"signature": "(value: unknown, idCase?: G9IdCase): unknown",
|
|
1846
|
+
"summary": "MAUI `NormalizeIdLikeValue`: `null` stays null, text is normalised (`''` for blank), anything else passes."
|
|
1847
|
+
},
|
|
1848
|
+
{
|
|
1849
|
+
"id": "sqlite.sqlite.normalizeRequiredId",
|
|
1850
|
+
"export": "normalizeRequiredId",
|
|
1851
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1852
|
+
"kind": "function",
|
|
1853
|
+
"signature": "(value: string | null | undefined, idCase?: G9IdCase): string",
|
|
1854
|
+
"summary": "MAUI `NormalizeRequiredSqliteGuidId`: like `normalizeId` but `''` instead of `null`."
|
|
1855
|
+
},
|
|
1856
|
+
{
|
|
1857
|
+
"id": "sqlite.sqlite.not",
|
|
1858
|
+
"export": "not",
|
|
1859
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1860
|
+
"kind": "function",
|
|
1861
|
+
"signature": "(operand: G9Expr | G9ColumnRef<boolean>): G9Expr",
|
|
1862
|
+
"summary": "C# `!`: `NOT (…)`; for a boolean column, MAUI's `col = 0`."
|
|
1863
|
+
},
|
|
1864
|
+
{
|
|
1865
|
+
"id": "sqlite.sqlite.notInList",
|
|
1866
|
+
"export": "notInList",
|
|
1867
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1868
|
+
"kind": "function",
|
|
1869
|
+
"signature": "<T>(operand: G9Operand<T>, values: Iterable<T | null>): G9Expr",
|
|
1870
|
+
"summary": "C# `!list.Contains(x.Col)`, emitted as MAUI did: `NOT (col IN (…))`, so — exactly like the MAUI query — rows whose column is NULL are not returned. A `null` in the list is handled explicitly (`col IS NOT NULL AND NOT …`) instead of falling into SQL's `NOT IN (…, NULL)` trap that returns nothing. An empty list matches every row."
|
|
1871
|
+
},
|
|
1872
|
+
{
|
|
1873
|
+
"id": "sqlite.sqlite.notNullOrEmpty",
|
|
1874
|
+
"export": "notNullOrEmpty",
|
|
1875
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1876
|
+
"kind": "function",
|
|
1877
|
+
"signature": "(operand: G9Operand<string>): G9Expr",
|
|
1878
|
+
"summary": "MAUI idiom `x.Code != null && x.Code != \"\"`: `col IS NOT NULL AND col <> ''`."
|
|
1879
|
+
},
|
|
1880
|
+
{
|
|
1881
|
+
"id": "sqlite.sqlite.or",
|
|
1882
|
+
"export": "or",
|
|
1883
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1884
|
+
"kind": "function",
|
|
1885
|
+
"signature": "(...items: (false | G9Expr | null | undefined)[]): G9Expr",
|
|
1886
|
+
"summary": "Logical OR of the given predicates (falsy entries are skipped)."
|
|
1887
|
+
},
|
|
1888
|
+
{
|
|
1889
|
+
"id": "sqlite.sqlite.parseGuidHex",
|
|
1890
|
+
"export": "parseGuidHex",
|
|
1891
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1892
|
+
"kind": "function",
|
|
1893
|
+
"signature": "(text: string): string | null",
|
|
1894
|
+
"summary": "The 32 hex digits of a GUID in any form .NET `Guid.TryParse` accepts (`D`, `N`, `B`, `P`, `X`), or `null`. Surrounding whitespace is ignored, as .NET does."
|
|
1895
|
+
},
|
|
1896
|
+
{
|
|
1897
|
+
"id": "sqlite.sqlite.parseInt64",
|
|
1898
|
+
"export": "parseInt64",
|
|
1899
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1900
|
+
"kind": "function",
|
|
1901
|
+
"signature": "(value: string | number): G9Int64",
|
|
1902
|
+
"summary": "Parses a decimal integer (optional sign, leading zeros allowed) or a safe-integer `number` into a canonical `G9Int64`. Throws a `misuse` `G9SqliteError` for anything else, including unsafe numbers (their exact value is already lost) and values outside the int64 range."
|
|
1903
|
+
},
|
|
1904
|
+
{
|
|
1905
|
+
"id": "sqlite.sqlite.parseLegacyDateTime",
|
|
1906
|
+
"export": "parseLegacyDateTime",
|
|
1907
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1908
|
+
"kind": "function",
|
|
1909
|
+
"signature": "(text: string): G9LocalDateTime",
|
|
1910
|
+
"summary": "Reads both stored families losslessly: `yyyy-MM-dd HH:mm:ss[.F…]` (provider) and `yyyy-MM-ddTHH:mm:ss[.f…]` (sync), with 0–7 fraction digits. Anything else (an offset, a `Z`, a date alone) is rejected with `misuse`: guessing a zone would silently move the instant."
|
|
1911
|
+
},
|
|
1912
|
+
{
|
|
1913
|
+
"id": "sqlite.sqlite.perUserDatabaseLocator",
|
|
1914
|
+
"export": "perUserDatabaseLocator",
|
|
1915
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1916
|
+
"kind": "function",
|
|
1917
|
+
"signature": "(options: { readonly root: string; readonly userId: () => string | null; readonly fileName?: string; readonly invalidFileNameChars?: string; }): G9PerUserDatabaseLocator",
|
|
1918
|
+
"summary": "MAUI `G9PerUserDatabaseLocator`: `<root>/users/<userId>/<fileName>`. ⚠ The directory name is the raw user id with invalid file-name characters removed, exactly as MAUI derived it: changing the id form orphans existing directories. Throws (`misuse`) when no user is active, so nothing silently opens a shared file."
|
|
1919
|
+
},
|
|
1920
|
+
{
|
|
1921
|
+
"id": "sqlite.sqlite.pragmaStatements",
|
|
1922
|
+
"export": "pragmaStatements",
|
|
1923
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1924
|
+
"kind": "function",
|
|
1925
|
+
"signature": "(pragmas: G9ConnectionPragmas, durability: G9Durability | undefined): string[]",
|
|
1926
|
+
"summary": "The PRAGMA statements for `G9ConnectionPragmas`, in application order (for drivers)."
|
|
1927
|
+
},
|
|
1928
|
+
{
|
|
1929
|
+
"id": "sqlite.sqlite.quoteIdentifier",
|
|
1930
|
+
"export": "quoteIdentifier",
|
|
1931
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1932
|
+
"kind": "function",
|
|
1933
|
+
"signature": "(identifier: string): string",
|
|
1934
|
+
"summary": "Quotes an identifier for SQLite (`\"Order\"`, embedded quotes doubled)."
|
|
1935
|
+
},
|
|
1936
|
+
{
|
|
1937
|
+
"id": "sqlite.sqlite.randomBytes16",
|
|
1938
|
+
"export": "randomBytes16",
|
|
1939
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1940
|
+
"kind": "function",
|
|
1941
|
+
"signature": "(): Uint8Array<ArrayBufferLike>",
|
|
1942
|
+
"summary": "Fills 16 random bytes: the platform CSPRNG when present, otherwise `Math.random` (documented weaker fallback)."
|
|
1943
|
+
},
|
|
1944
|
+
{
|
|
1945
|
+
"id": "sqlite.sqlite.raw",
|
|
1946
|
+
"export": "raw",
|
|
1947
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1948
|
+
"kind": "function",
|
|
1949
|
+
"signature": "(sql: string, ...params: unknown[]): G9Expr",
|
|
1950
|
+
"summary": "A raw SQL fragment with positional `?` parameters (outside every G9 rule: no id normalisation, no codecs)."
|
|
1951
|
+
},
|
|
1952
|
+
{
|
|
1953
|
+
"id": "sqlite.sqlite.real",
|
|
1954
|
+
"export": "real",
|
|
1955
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1956
|
+
"kind": "function",
|
|
1957
|
+
"signature": "(): G9Column<number, false, false>",
|
|
1958
|
+
"summary": "REAL (double)."
|
|
1959
|
+
},
|
|
1960
|
+
{
|
|
1961
|
+
"id": "sqlite.sqlite.realCodec",
|
|
1962
|
+
"export": "realCodec",
|
|
1963
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1964
|
+
"kind": "constant",
|
|
1965
|
+
"signature": "G9Codec<number>",
|
|
1966
|
+
"summary": "REAL (double)."
|
|
1967
|
+
},
|
|
1968
|
+
{
|
|
1969
|
+
"id": "sqlite.sqlite.resolveCurrentUserId",
|
|
1970
|
+
"export": "resolveCurrentUserId",
|
|
1971
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1972
|
+
"kind": "function",
|
|
1973
|
+
"signature": "(provider: G9CurrentUserProvider, idCase: G9IdCase): string | null",
|
|
1974
|
+
"summary": "MAUI `SqliteEntityAuditDefaults.ResolveCurrentUserId`: the provider's id, normalised; `null` when the provider throws (a provider must never fail a write: an unattributed row is recoverable, a lost one is not)."
|
|
1975
|
+
},
|
|
1976
|
+
{
|
|
1977
|
+
"id": "sqlite.sqlite.runContractSuite",
|
|
1978
|
+
"export": "runContractSuite",
|
|
1979
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1980
|
+
"kind": "function",
|
|
1981
|
+
"signature": "(driver: G9SqliteDriver, cases: G9ContractCases, options: G9ContractRunOptions): Promise<G9ContractReport>",
|
|
1982
|
+
"summary": "Runs the driver contract (`@g9tm/lynxcontrols-sqlite/contract/cases.json`) against a driver and reports every failure. The same data drives the Node reference driver, the Lynxtron worker, the Android JVM core and the iOS XCTest suite."
|
|
1983
|
+
},
|
|
1984
|
+
{
|
|
1985
|
+
"id": "sqlite.sqlite.singleFileDatabaseLocator",
|
|
1986
|
+
"export": "singleFileDatabaseLocator",
|
|
1987
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1988
|
+
"kind": "function",
|
|
1989
|
+
"signature": "(path: string): G9DatabaseLocator",
|
|
1990
|
+
"summary": "MAUI `G9SingleFileDatabaseLocator`: one file at a fixed path. The right default for a single-user app."
|
|
1991
|
+
},
|
|
1992
|
+
{
|
|
1993
|
+
"id": "sqlite.sqlite.sortMigrations",
|
|
1994
|
+
"export": "sortMigrations",
|
|
1995
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
1996
|
+
"kind": "function",
|
|
1997
|
+
"signature": "(migrations: readonly G9Migration[]): readonly G9Migration[]",
|
|
1998
|
+
"summary": "Validates and sorts a migration list (duplicate versions and names are configuration errors)."
|
|
1999
|
+
},
|
|
2000
|
+
{
|
|
2001
|
+
"id": "sqlite.sqlite.sqlEq",
|
|
2002
|
+
"export": "sqlEq",
|
|
2003
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2004
|
+
"kind": "function",
|
|
2005
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
2006
|
+
"summary": "Plain SQL `=` (NULL never matches)."
|
|
2007
|
+
},
|
|
2008
|
+
{
|
|
2009
|
+
"id": "sqlite.sqlite.sqliteErrorCodeFor",
|
|
2010
|
+
"export": "sqliteErrorCodeFor",
|
|
2011
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2012
|
+
"kind": "function",
|
|
2013
|
+
"signature": "(resultCode: number): G9SqliteErrorCode",
|
|
2014
|
+
"summary": "Maps a SQLite (extended) result code to a `G9SqliteErrorCode`. The primary code is the low byte (https://sqlite.org/rescode.html)."
|
|
2015
|
+
},
|
|
2016
|
+
{
|
|
2017
|
+
"id": "sqlite.sqlite.sqlNe",
|
|
2018
|
+
"export": "sqlNe",
|
|
2019
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2020
|
+
"kind": "function",
|
|
2021
|
+
"signature": "<T>(left: G9Operand<T>, right: G9Operand<T>): G9Expr",
|
|
2022
|
+
"summary": "Plain SQL `<>`: rows with NULL in the column are NOT returned (unlike `ne`)."
|
|
2023
|
+
},
|
|
2024
|
+
{
|
|
2025
|
+
"id": "sqlite.sqlite.sqlValueEquals",
|
|
2026
|
+
"export": "sqlValueEquals",
|
|
2027
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2028
|
+
"kind": "function",
|
|
2029
|
+
"signature": "(a: G9SqlValue, b: G9SqlValue): boolean",
|
|
2030
|
+
"summary": "Structural equality of two `G9SqlValue`s (BLOBs by bytes, int64 tags by value)."
|
|
2031
|
+
},
|
|
2032
|
+
{
|
|
2033
|
+
"id": "sqlite.sqlite.startsWith",
|
|
2034
|
+
"export": "startsWith",
|
|
2035
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2036
|
+
"kind": "function",
|
|
2037
|
+
"signature": "(operand: G9Operand<string>, prefix: string): G9Expr",
|
|
2038
|
+
"summary": "C# `StartsWith`: `LIKE 's%' ESCAPE '\\'`."
|
|
2039
|
+
},
|
|
2040
|
+
{
|
|
2041
|
+
"id": "sqlite.sqlite.sub",
|
|
2042
|
+
"export": "sub",
|
|
2043
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2044
|
+
"kind": "function",
|
|
2045
|
+
"signature": "(left: G9Operand<number>, right: G9Operand<number>): G9Expr",
|
|
2046
|
+
"summary": "Arithmetic `-` (parenthesised)."
|
|
2047
|
+
},
|
|
2048
|
+
{
|
|
2049
|
+
"id": "sqlite.sqlite.subtractInt64",
|
|
2050
|
+
"export": "subtractInt64",
|
|
2051
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2052
|
+
"kind": "function",
|
|
2053
|
+
"signature": "(a: G9Int64, b: G9Int64): G9Int64",
|
|
2054
|
+
"summary": "a − b; throws `misuse` on overflow."
|
|
2055
|
+
},
|
|
2056
|
+
{
|
|
2057
|
+
"id": "sqlite.sqlite.sum",
|
|
2058
|
+
"export": "sum",
|
|
2059
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2060
|
+
"kind": "function",
|
|
2061
|
+
"signature": "(operand: G9Operand<number>): G9Expr",
|
|
2062
|
+
"summary": "`SUM(col)`."
|
|
2063
|
+
},
|
|
2064
|
+
{
|
|
2065
|
+
"id": "sqlite.sqlite.text",
|
|
2066
|
+
"export": "text",
|
|
2067
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2068
|
+
"kind": "function",
|
|
2069
|
+
"signature": "(): G9Column<string, false, false>",
|
|
2070
|
+
"summary": "TEXT."
|
|
2071
|
+
},
|
|
2072
|
+
{
|
|
2073
|
+
"id": "sqlite.sqlite.textCodec",
|
|
2074
|
+
"export": "textCodec",
|
|
2075
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2076
|
+
"kind": "constant",
|
|
2077
|
+
"signature": "G9Codec<string>",
|
|
2078
|
+
"summary": "TEXT. Reads numbers stored in a TEXT column (affinity drift) as their exact decimal text."
|
|
2079
|
+
},
|
|
2080
|
+
{
|
|
2081
|
+
"id": "sqlite.sqlite.toArrayBuffer",
|
|
2082
|
+
"export": "toArrayBuffer",
|
|
2083
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2084
|
+
"kind": "function",
|
|
2085
|
+
"signature": "(bytes: ArrayBuffer | ArrayBufferView<ArrayBufferLike>): ArrayBuffer",
|
|
2086
|
+
"summary": "Copies the bytes of a typed array or buffer into a standalone `ArrayBuffer`."
|
|
2087
|
+
},
|
|
2088
|
+
{
|
|
2089
|
+
"id": "sqlite.sqlite.toExpr",
|
|
2090
|
+
"export": "toExpr",
|
|
2091
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2092
|
+
"kind": "function",
|
|
2093
|
+
"signature": "(operand: unknown): G9Expr",
|
|
2094
|
+
"summary": "Wraps a plain value as a bound parameter; expressions pass through."
|
|
2095
|
+
},
|
|
2096
|
+
{
|
|
2097
|
+
"id": "sqlite.sqlite.toSqlLiteral",
|
|
2098
|
+
"export": "toSqlLiteral",
|
|
2099
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2100
|
+
"kind": "function",
|
|
2101
|
+
"signature": "(value: G9SqlValue): string",
|
|
2102
|
+
"summary": "MAUI `ToSqlLiteral`: a value as a SQL literal (diagnostics)."
|
|
2103
|
+
},
|
|
2104
|
+
{
|
|
2105
|
+
"id": "sqlite.sqlite.upper",
|
|
2106
|
+
"export": "upper",
|
|
2107
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2108
|
+
"kind": "function",
|
|
2109
|
+
"signature": "(operand: G9Operand<string>): G9Expr",
|
|
2110
|
+
"summary": "`UPPER(col)`."
|
|
2111
|
+
},
|
|
2112
|
+
{
|
|
2113
|
+
"id": "sqlite.sqlite.upsert",
|
|
2114
|
+
"export": "upsert",
|
|
2115
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2116
|
+
"kind": "function",
|
|
2117
|
+
"signature": "(options?: { target?: readonly string[]; update?: readonly string[]; }): G9UpsertPolicy",
|
|
2118
|
+
"summary": "An upsert on the given conflict target, optionally limited to some update columns."
|
|
2119
|
+
},
|
|
2120
|
+
{
|
|
2121
|
+
"id": "sqlite.sqlite.value",
|
|
2122
|
+
"export": "value",
|
|
2123
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2124
|
+
"kind": "function",
|
|
2125
|
+
"signature": "(v: unknown): G9Expr",
|
|
2126
|
+
"summary": "A plain value as an explicit parameter (rarely needed: operators wrap values themselves)."
|
|
2127
|
+
},
|
|
2128
|
+
{
|
|
2129
|
+
"id": "sqlite.sqlite.writeRowAs",
|
|
2130
|
+
"export": "writeRowAs",
|
|
2131
|
+
"from": "@g9tm/lynxcontrols-sqlite",
|
|
2132
|
+
"kind": "function",
|
|
2133
|
+
"signature": "<E extends G9EntityDescriptor>(context: G9WriteContext<Record<string, unknown>>, entity: E): (E extends G9EntityDescriptor<infer C extends G9Columns> ? { [K in keyof C]: unknown; } : never) | null",
|
|
2134
|
+
"summary": "MAUI `G9WriteContext.EntityAs<T>()`: the row when the write is for `entity`, otherwise `null`."
|
|
2135
|
+
}
|
|
2136
|
+
]
|
|
2137
|
+
}
|