@tinyshed/tinystore 0.8.0 → 0.9.0
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/README.md +1 -1
- package/dist/backup.d.ts +2 -0
- package/dist/backup.js +1 -0
- package/dist/blobs.d.ts +18 -1
- package/dist/blobs.js +52 -45
- package/dist/directory.d.ts +72 -0
- package/dist/directory.js +121 -0
- package/dist/index.d.ts +2 -1
- package/dist/jobs.d.ts +33 -9
- package/dist/jobs.js +137 -34
- package/dist/metrics.d.ts +5 -1
- package/dist/metrics.js +2 -0
- package/dist/query.d.ts +8 -1
- package/dist/query.js +25 -4
- package/dist/search.d.ts +6 -1
- package/dist/search.js +4 -2
- package/dist/sql.d.ts +26 -2
- package/dist/sql.js +18 -5
- package/dist/store.d.ts +9 -0
- package/dist/store.js +11 -0
- package/dist/wire/protocol.d.ts +200 -7
- package/dist/wire/protocol.js +602 -13
- package/package.json +8 -8
- package/src/backup.ts +3 -0
- package/src/blobs.ts +66 -45
- package/src/directory.ts +235 -0
- package/src/index.ts +9 -0
- package/src/jobs.ts +178 -41
- package/src/metrics.ts +7 -1
- package/src/query.ts +28 -6
- package/src/search.ts +10 -5
- package/src/sql.ts +35 -5
- package/src/store.ts +12 -0
- package/src/wire/protocol.ts +637 -13
package/src/wire/protocol.ts
CHANGED
|
@@ -36,6 +36,10 @@ export const methods = {
|
|
|
36
36
|
'blobs.usage': 0x040b,
|
|
37
37
|
'blobs.clear': 0x040c,
|
|
38
38
|
'blobs.read': 0x040d,
|
|
39
|
+
'blobs.directory': 0x040e,
|
|
40
|
+
'blobs.scan': 0x040f,
|
|
41
|
+
'blobs.changes': 0x0410,
|
|
42
|
+
'blobs.forget': 0x0411,
|
|
39
43
|
/**
|
|
40
44
|
* Answers once the store has the message, not once anyone handled it; in a
|
|
41
45
|
* database's transaction, it is handed over once the transaction commits.
|
|
@@ -68,6 +72,7 @@ export const methods = {
|
|
|
68
72
|
'jobs.keep': 0x020b,
|
|
69
73
|
'jobs.watch': 0x020c,
|
|
70
74
|
'jobs.tx': 0x020d,
|
|
75
|
+
'jobs.counts': 0x020e,
|
|
71
76
|
'kv.bucket.open': 0x0101,
|
|
72
77
|
'kv.get': 0x0102,
|
|
73
78
|
'kv.has': 0x0103,
|
|
@@ -280,6 +285,8 @@ export const BackupWritten = message(
|
|
|
280
285
|
bytes: [2, uint],
|
|
281
286
|
/** the store seals values with a key the backup does not hold */
|
|
282
287
|
keyLeftOut: [3, bool],
|
|
288
|
+
/** the databases opened with backup false, which it holds nothing of */
|
|
289
|
+
excluded: [4, list(str)],
|
|
283
290
|
},
|
|
284
291
|
{
|
|
285
292
|
write(w, v) {
|
|
@@ -300,12 +307,21 @@ export const BackupWritten = message(
|
|
|
300
307
|
w.bool(v.keyLeftOut)
|
|
301
308
|
n++
|
|
302
309
|
}
|
|
310
|
+
if (v.excluded !== undefined) {
|
|
311
|
+
w.field(4)
|
|
312
|
+
w.array(v.excluded.length)
|
|
313
|
+
for (const item0 of v.excluded) {
|
|
314
|
+
w.str(item0)
|
|
315
|
+
}
|
|
316
|
+
n++
|
|
317
|
+
}
|
|
303
318
|
w.closeMap(head, n)
|
|
304
319
|
},
|
|
305
320
|
read(r) {
|
|
306
321
|
let $files: number | undefined
|
|
307
322
|
let $bytes: number | undefined
|
|
308
323
|
let $keyLeftOut: boolean | undefined
|
|
324
|
+
let $excluded: string[] | undefined
|
|
309
325
|
for (let n = r.message(); n > 0; n--) {
|
|
310
326
|
switch (r.field()) {
|
|
311
327
|
case 1:
|
|
@@ -317,12 +333,21 @@ export const BackupWritten = message(
|
|
|
317
333
|
case 3:
|
|
318
334
|
$keyLeftOut = r.bool()
|
|
319
335
|
break
|
|
336
|
+
case 4: {
|
|
337
|
+
const items0: string[] = []
|
|
338
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
339
|
+
items0.push(r.str())
|
|
340
|
+
}
|
|
341
|
+
r.leave()
|
|
342
|
+
$excluded = items0
|
|
343
|
+
break
|
|
344
|
+
}
|
|
320
345
|
default:
|
|
321
346
|
r.skip()
|
|
322
347
|
}
|
|
323
348
|
}
|
|
324
349
|
r.leave()
|
|
325
|
-
return { files: $files, bytes: $bytes, keyLeftOut: $keyLeftOut }
|
|
350
|
+
return { files: $files, bytes: $bytes, keyLeftOut: $keyLeftOut, excluded: $excluded }
|
|
326
351
|
},
|
|
327
352
|
},
|
|
328
353
|
)
|
|
@@ -758,12 +783,15 @@ export const BlobsWritten = message(
|
|
|
758
783
|
|
|
759
784
|
/**
|
|
760
785
|
* A piece of a file's bytes: an upload's DATA from the client, a read's from
|
|
761
|
-
* the server.
|
|
786
|
+
* the server. A piece of a growing directory's file brings the file's size
|
|
787
|
+
* and time as it was read, so that the reader sees it moved.
|
|
762
788
|
*/
|
|
763
789
|
export const BlobsPiece = message(
|
|
764
790
|
'blobs.Piece',
|
|
765
791
|
{
|
|
766
792
|
bytes: [1, bin],
|
|
793
|
+
size: [2, uint],
|
|
794
|
+
lastModified: [3, int],
|
|
767
795
|
},
|
|
768
796
|
{
|
|
769
797
|
write(w, v) {
|
|
@@ -774,21 +802,39 @@ export const BlobsPiece = message(
|
|
|
774
802
|
w.bin(v.bytes)
|
|
775
803
|
n++
|
|
776
804
|
}
|
|
805
|
+
if (v.size !== undefined) {
|
|
806
|
+
w.field(2)
|
|
807
|
+
w.uint(v.size)
|
|
808
|
+
n++
|
|
809
|
+
}
|
|
810
|
+
if (v.lastModified !== undefined) {
|
|
811
|
+
w.field(3)
|
|
812
|
+
w.int(v.lastModified)
|
|
813
|
+
n++
|
|
814
|
+
}
|
|
777
815
|
w.closeMap(head, n)
|
|
778
816
|
},
|
|
779
817
|
read(r) {
|
|
780
818
|
let $bytes: Uint8Array | undefined
|
|
819
|
+
let $size: number | undefined
|
|
820
|
+
let $lastModified: number | undefined
|
|
781
821
|
for (let n = r.message(); n > 0; n--) {
|
|
782
822
|
switch (r.field()) {
|
|
783
823
|
case 1:
|
|
784
824
|
$bytes = r.bytes()
|
|
785
825
|
break
|
|
826
|
+
case 2:
|
|
827
|
+
$size = r.uint()
|
|
828
|
+
break
|
|
829
|
+
case 3:
|
|
830
|
+
$lastModified = r.int()
|
|
831
|
+
break
|
|
786
832
|
default:
|
|
787
833
|
r.skip()
|
|
788
834
|
}
|
|
789
835
|
}
|
|
790
836
|
r.leave()
|
|
791
|
-
return { bytes: $bytes }
|
|
837
|
+
return { bytes: $bytes, size: $size, lastModified: $lastModified }
|
|
792
838
|
},
|
|
793
839
|
},
|
|
794
840
|
)
|
|
@@ -1480,6 +1526,356 @@ export const BlobsUsage = message(
|
|
|
1480
1526
|
},
|
|
1481
1527
|
)
|
|
1482
1528
|
|
|
1529
|
+
/**
|
|
1530
|
+
* Opens a directory by name: a folder of the server's machine, which the
|
|
1531
|
+
* store lists and reads and never writes. Its handle takes get, head, list,
|
|
1532
|
+
* usage and read as a set of files' does, each answered from the list the
|
|
1533
|
+
* last scan wrote but a get's and a read's bytes, which come from the disk;
|
|
1534
|
+
* every call that writes a file is invalid. A connection that came with a
|
|
1535
|
+
* token names no path: it opens the directory the server was given under the
|
|
1536
|
+
* name, and one the server was not given is invalid.
|
|
1537
|
+
*/
|
|
1538
|
+
export const BlobsDirectory = message(
|
|
1539
|
+
'blobs.Directory',
|
|
1540
|
+
{
|
|
1541
|
+
/** [a-z0-9][a-z0-9_-]{0,63}, never a set of files' name too */
|
|
1542
|
+
name: [1, str],
|
|
1543
|
+
/** the folder on the server's machine; the server's own when absent */
|
|
1544
|
+
path: [2, str],
|
|
1545
|
+
/** a scan on the store's background work, a period apart */
|
|
1546
|
+
every: [3, uint],
|
|
1547
|
+
/** names a scan passes over, * for any run of a name's characters */
|
|
1548
|
+
ignore: [4, list(str)],
|
|
1549
|
+
/** a read holds to no version and goes up to the size now */
|
|
1550
|
+
growing: [5, bool],
|
|
1551
|
+
},
|
|
1552
|
+
{
|
|
1553
|
+
write(w, v) {
|
|
1554
|
+
const head = w.openMap()
|
|
1555
|
+
let n = 0
|
|
1556
|
+
if (v.name !== undefined) {
|
|
1557
|
+
w.field(1)
|
|
1558
|
+
w.str(v.name)
|
|
1559
|
+
n++
|
|
1560
|
+
}
|
|
1561
|
+
if (v.path !== undefined) {
|
|
1562
|
+
w.field(2)
|
|
1563
|
+
w.str(v.path)
|
|
1564
|
+
n++
|
|
1565
|
+
}
|
|
1566
|
+
if (v.every !== undefined) {
|
|
1567
|
+
w.field(3)
|
|
1568
|
+
w.uint(v.every)
|
|
1569
|
+
n++
|
|
1570
|
+
}
|
|
1571
|
+
if (v.ignore !== undefined) {
|
|
1572
|
+
w.field(4)
|
|
1573
|
+
w.array(v.ignore.length)
|
|
1574
|
+
for (const item0 of v.ignore) {
|
|
1575
|
+
w.str(item0)
|
|
1576
|
+
}
|
|
1577
|
+
n++
|
|
1578
|
+
}
|
|
1579
|
+
if (v.growing !== undefined) {
|
|
1580
|
+
w.field(5)
|
|
1581
|
+
w.bool(v.growing)
|
|
1582
|
+
n++
|
|
1583
|
+
}
|
|
1584
|
+
w.closeMap(head, n)
|
|
1585
|
+
},
|
|
1586
|
+
read(r) {
|
|
1587
|
+
let $name: string | undefined
|
|
1588
|
+
let $path: string | undefined
|
|
1589
|
+
let $every: number | undefined
|
|
1590
|
+
let $ignore: string[] | undefined
|
|
1591
|
+
let $growing: boolean | undefined
|
|
1592
|
+
for (let n = r.message(); n > 0; n--) {
|
|
1593
|
+
switch (r.field()) {
|
|
1594
|
+
case 1:
|
|
1595
|
+
$name = r.str()
|
|
1596
|
+
break
|
|
1597
|
+
case 2:
|
|
1598
|
+
$path = r.str()
|
|
1599
|
+
break
|
|
1600
|
+
case 3:
|
|
1601
|
+
$every = r.uint()
|
|
1602
|
+
break
|
|
1603
|
+
case 4: {
|
|
1604
|
+
const items0: string[] = []
|
|
1605
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
1606
|
+
items0.push(r.str())
|
|
1607
|
+
}
|
|
1608
|
+
r.leave()
|
|
1609
|
+
$ignore = items0
|
|
1610
|
+
break
|
|
1611
|
+
}
|
|
1612
|
+
case 5:
|
|
1613
|
+
$growing = r.bool()
|
|
1614
|
+
break
|
|
1615
|
+
default:
|
|
1616
|
+
r.skip()
|
|
1617
|
+
}
|
|
1618
|
+
}
|
|
1619
|
+
r.leave()
|
|
1620
|
+
return { name: $name, path: $path, every: $every, ignore: $ignore, growing: $growing }
|
|
1621
|
+
},
|
|
1622
|
+
},
|
|
1623
|
+
)
|
|
1624
|
+
|
|
1625
|
+
/**
|
|
1626
|
+
* What a scan found, and what the list holds once it ended.
|
|
1627
|
+
*/
|
|
1628
|
+
export const BlobsScanned = message(
|
|
1629
|
+
'blobs.Scanned',
|
|
1630
|
+
{
|
|
1631
|
+
added: [1, uint],
|
|
1632
|
+
changed: [2, uint],
|
|
1633
|
+
removed: [3, uint],
|
|
1634
|
+
/** what it met and could not list: a link, a folder it cannot read, another disk */
|
|
1635
|
+
skipped: [4, uint],
|
|
1636
|
+
count: [5, uint],
|
|
1637
|
+
size: [6, uint],
|
|
1638
|
+
},
|
|
1639
|
+
{
|
|
1640
|
+
write(w, v) {
|
|
1641
|
+
const head = w.openMap()
|
|
1642
|
+
let n = 0
|
|
1643
|
+
if (v.added !== undefined) {
|
|
1644
|
+
w.field(1)
|
|
1645
|
+
w.uint(v.added)
|
|
1646
|
+
n++
|
|
1647
|
+
}
|
|
1648
|
+
if (v.changed !== undefined) {
|
|
1649
|
+
w.field(2)
|
|
1650
|
+
w.uint(v.changed)
|
|
1651
|
+
n++
|
|
1652
|
+
}
|
|
1653
|
+
if (v.removed !== undefined) {
|
|
1654
|
+
w.field(3)
|
|
1655
|
+
w.uint(v.removed)
|
|
1656
|
+
n++
|
|
1657
|
+
}
|
|
1658
|
+
if (v.skipped !== undefined) {
|
|
1659
|
+
w.field(4)
|
|
1660
|
+
w.uint(v.skipped)
|
|
1661
|
+
n++
|
|
1662
|
+
}
|
|
1663
|
+
if (v.count !== undefined) {
|
|
1664
|
+
w.field(5)
|
|
1665
|
+
w.uint(v.count)
|
|
1666
|
+
n++
|
|
1667
|
+
}
|
|
1668
|
+
if (v.size !== undefined) {
|
|
1669
|
+
w.field(6)
|
|
1670
|
+
w.uint(v.size)
|
|
1671
|
+
n++
|
|
1672
|
+
}
|
|
1673
|
+
w.closeMap(head, n)
|
|
1674
|
+
},
|
|
1675
|
+
read(r) {
|
|
1676
|
+
let $added: number | undefined
|
|
1677
|
+
let $changed: number | undefined
|
|
1678
|
+
let $removed: number | undefined
|
|
1679
|
+
let $skipped: number | undefined
|
|
1680
|
+
let $count: number | undefined
|
|
1681
|
+
let $size: number | undefined
|
|
1682
|
+
for (let n = r.message(); n > 0; n--) {
|
|
1683
|
+
switch (r.field()) {
|
|
1684
|
+
case 1:
|
|
1685
|
+
$added = r.uint()
|
|
1686
|
+
break
|
|
1687
|
+
case 2:
|
|
1688
|
+
$changed = r.uint()
|
|
1689
|
+
break
|
|
1690
|
+
case 3:
|
|
1691
|
+
$removed = r.uint()
|
|
1692
|
+
break
|
|
1693
|
+
case 4:
|
|
1694
|
+
$skipped = r.uint()
|
|
1695
|
+
break
|
|
1696
|
+
case 5:
|
|
1697
|
+
$count = r.uint()
|
|
1698
|
+
break
|
|
1699
|
+
case 6:
|
|
1700
|
+
$size = r.uint()
|
|
1701
|
+
break
|
|
1702
|
+
default:
|
|
1703
|
+
r.skip()
|
|
1704
|
+
}
|
|
1705
|
+
}
|
|
1706
|
+
r.leave()
|
|
1707
|
+
return {
|
|
1708
|
+
added: $added,
|
|
1709
|
+
changed: $changed,
|
|
1710
|
+
removed: $removed,
|
|
1711
|
+
skipped: $skipped,
|
|
1712
|
+
count: $count,
|
|
1713
|
+
size: $size,
|
|
1714
|
+
}
|
|
1715
|
+
},
|
|
1716
|
+
},
|
|
1717
|
+
)
|
|
1718
|
+
|
|
1719
|
+
/**
|
|
1720
|
+
* The changes of a directory past a cursor, from the first file it listed
|
|
1721
|
+
* when absent.
|
|
1722
|
+
*/
|
|
1723
|
+
export const BlobsSince = message(
|
|
1724
|
+
'blobs.Since',
|
|
1725
|
+
{
|
|
1726
|
+
handle: [1, uint],
|
|
1727
|
+
/** a page's next */
|
|
1728
|
+
after: [2, str],
|
|
1729
|
+
},
|
|
1730
|
+
{
|
|
1731
|
+
write(w, v) {
|
|
1732
|
+
const head = w.openMap()
|
|
1733
|
+
let n = 0
|
|
1734
|
+
if (v.handle !== undefined) {
|
|
1735
|
+
w.field(1)
|
|
1736
|
+
w.uint(v.handle)
|
|
1737
|
+
n++
|
|
1738
|
+
}
|
|
1739
|
+
if (v.after !== undefined) {
|
|
1740
|
+
w.field(2)
|
|
1741
|
+
w.str(v.after)
|
|
1742
|
+
n++
|
|
1743
|
+
}
|
|
1744
|
+
w.closeMap(head, n)
|
|
1745
|
+
},
|
|
1746
|
+
read(r) {
|
|
1747
|
+
let $handle: number | undefined
|
|
1748
|
+
let $after: string | undefined
|
|
1749
|
+
for (let n = r.message(); n > 0; n--) {
|
|
1750
|
+
switch (r.field()) {
|
|
1751
|
+
case 1:
|
|
1752
|
+
$handle = r.uint()
|
|
1753
|
+
break
|
|
1754
|
+
case 2:
|
|
1755
|
+
$after = r.str()
|
|
1756
|
+
break
|
|
1757
|
+
default:
|
|
1758
|
+
r.skip()
|
|
1759
|
+
}
|
|
1760
|
+
}
|
|
1761
|
+
r.leave()
|
|
1762
|
+
return { handle: $handle, after: $after }
|
|
1763
|
+
},
|
|
1764
|
+
},
|
|
1765
|
+
)
|
|
1766
|
+
|
|
1767
|
+
export const BlobsChange = message(
|
|
1768
|
+
'blobs.Change',
|
|
1769
|
+
{
|
|
1770
|
+
/** the whole path in the directory */
|
|
1771
|
+
path: [1, str],
|
|
1772
|
+
/** added, changed or removed */
|
|
1773
|
+
change: [2, str],
|
|
1774
|
+
/** none once removed */
|
|
1775
|
+
info: [3, BlobsInfo],
|
|
1776
|
+
},
|
|
1777
|
+
{
|
|
1778
|
+
write(w, v) {
|
|
1779
|
+
const head = w.openMap()
|
|
1780
|
+
let n = 0
|
|
1781
|
+
if (v.path !== undefined) {
|
|
1782
|
+
w.field(1)
|
|
1783
|
+
w.str(v.path)
|
|
1784
|
+
n++
|
|
1785
|
+
}
|
|
1786
|
+
if (v.change !== undefined) {
|
|
1787
|
+
w.field(2)
|
|
1788
|
+
w.str(v.change)
|
|
1789
|
+
n++
|
|
1790
|
+
}
|
|
1791
|
+
if (v.info !== undefined) {
|
|
1792
|
+
w.field(3)
|
|
1793
|
+
BlobsInfo.write(w, v.info)
|
|
1794
|
+
n++
|
|
1795
|
+
}
|
|
1796
|
+
w.closeMap(head, n)
|
|
1797
|
+
},
|
|
1798
|
+
read(r) {
|
|
1799
|
+
let $path: string | undefined
|
|
1800
|
+
let $change: string | undefined
|
|
1801
|
+
let $info: Read<typeof BlobsInfo.fields> | undefined
|
|
1802
|
+
for (let n = r.message(); n > 0; n--) {
|
|
1803
|
+
switch (r.field()) {
|
|
1804
|
+
case 1:
|
|
1805
|
+
$path = r.str()
|
|
1806
|
+
break
|
|
1807
|
+
case 2:
|
|
1808
|
+
$change = r.str()
|
|
1809
|
+
break
|
|
1810
|
+
case 3:
|
|
1811
|
+
$info = BlobsInfo.read(r)
|
|
1812
|
+
break
|
|
1813
|
+
default:
|
|
1814
|
+
r.skip()
|
|
1815
|
+
}
|
|
1816
|
+
}
|
|
1817
|
+
r.leave()
|
|
1818
|
+
return { path: $path, change: $change, info: $info }
|
|
1819
|
+
},
|
|
1820
|
+
},
|
|
1821
|
+
)
|
|
1822
|
+
|
|
1823
|
+
/**
|
|
1824
|
+
* A page of changes in the order the scans wrote them, 1000 at most; next is
|
|
1825
|
+
* always there, with no items the cursor to ask from after the next scan.
|
|
1826
|
+
*/
|
|
1827
|
+
export const BlobsChanges = message(
|
|
1828
|
+
'blobs.Changes',
|
|
1829
|
+
{
|
|
1830
|
+
items: [1, list(BlobsChange)],
|
|
1831
|
+
next: [2, str],
|
|
1832
|
+
},
|
|
1833
|
+
{
|
|
1834
|
+
write(w, v) {
|
|
1835
|
+
const head = w.openMap()
|
|
1836
|
+
let n = 0
|
|
1837
|
+
if (v.items !== undefined) {
|
|
1838
|
+
w.field(1)
|
|
1839
|
+
w.array(v.items.length)
|
|
1840
|
+
for (const item0 of v.items) {
|
|
1841
|
+
BlobsChange.write(w, item0)
|
|
1842
|
+
}
|
|
1843
|
+
n++
|
|
1844
|
+
}
|
|
1845
|
+
if (v.next !== undefined) {
|
|
1846
|
+
w.field(2)
|
|
1847
|
+
w.str(v.next)
|
|
1848
|
+
n++
|
|
1849
|
+
}
|
|
1850
|
+
w.closeMap(head, n)
|
|
1851
|
+
},
|
|
1852
|
+
read(r) {
|
|
1853
|
+
let $items: Read<typeof BlobsChange.fields>[] | undefined
|
|
1854
|
+
let $next: string | undefined
|
|
1855
|
+
for (let n = r.message(); n > 0; n--) {
|
|
1856
|
+
switch (r.field()) {
|
|
1857
|
+
case 1: {
|
|
1858
|
+
const items0: Read<typeof BlobsChange.fields>[] = []
|
|
1859
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
1860
|
+
items0.push(BlobsChange.read(r))
|
|
1861
|
+
}
|
|
1862
|
+
r.leave()
|
|
1863
|
+
$items = items0
|
|
1864
|
+
break
|
|
1865
|
+
}
|
|
1866
|
+
case 2:
|
|
1867
|
+
$next = r.str()
|
|
1868
|
+
break
|
|
1869
|
+
default:
|
|
1870
|
+
r.skip()
|
|
1871
|
+
}
|
|
1872
|
+
}
|
|
1873
|
+
r.leave()
|
|
1874
|
+
return { items: $items, next: $next }
|
|
1875
|
+
},
|
|
1876
|
+
},
|
|
1877
|
+
)
|
|
1878
|
+
|
|
1483
1879
|
/**
|
|
1484
1880
|
* A message published on a channel's branch, as docs/guides/channels/README.md has
|
|
1485
1881
|
* it: every subscription listening there now receives it.
|
|
@@ -3213,13 +3609,15 @@ export const JobsCall = message(
|
|
|
3213
3609
|
)
|
|
3214
3610
|
|
|
3215
3611
|
/**
|
|
3216
|
-
* The job under an id
|
|
3612
|
+
* The job under an id; or, for a cancel, a job without one by the row a page
|
|
3613
|
+
* gave, its id left out.
|
|
3217
3614
|
*/
|
|
3218
3615
|
export const JobsId = message(
|
|
3219
3616
|
'jobs.Id',
|
|
3220
3617
|
{
|
|
3221
3618
|
handle: [1, uint],
|
|
3222
3619
|
id: [2, str],
|
|
3620
|
+
row: [3, str],
|
|
3223
3621
|
},
|
|
3224
3622
|
{
|
|
3225
3623
|
write(w, v) {
|
|
@@ -3235,11 +3633,17 @@ export const JobsId = message(
|
|
|
3235
3633
|
w.str(v.id)
|
|
3236
3634
|
n++
|
|
3237
3635
|
}
|
|
3636
|
+
if (v.row !== undefined) {
|
|
3637
|
+
w.field(3)
|
|
3638
|
+
w.str(v.row)
|
|
3639
|
+
n++
|
|
3640
|
+
}
|
|
3238
3641
|
w.closeMap(head, n)
|
|
3239
3642
|
},
|
|
3240
3643
|
read(r) {
|
|
3241
3644
|
let $handle: number | undefined
|
|
3242
3645
|
let $id: string | undefined
|
|
3646
|
+
let $row: string | undefined
|
|
3243
3647
|
for (let n = r.message(); n > 0; n--) {
|
|
3244
3648
|
switch (r.field()) {
|
|
3245
3649
|
case 1:
|
|
@@ -3248,12 +3652,15 @@ export const JobsId = message(
|
|
|
3248
3652
|
case 2:
|
|
3249
3653
|
$id = r.str()
|
|
3250
3654
|
break
|
|
3655
|
+
case 3:
|
|
3656
|
+
$row = r.str()
|
|
3657
|
+
break
|
|
3251
3658
|
default:
|
|
3252
3659
|
r.skip()
|
|
3253
3660
|
}
|
|
3254
3661
|
}
|
|
3255
3662
|
r.leave()
|
|
3256
|
-
return { handle: $handle, id: $id }
|
|
3663
|
+
return { handle: $handle, id: $id, row: $row }
|
|
3257
3664
|
},
|
|
3258
3665
|
},
|
|
3259
3666
|
)
|
|
@@ -3319,6 +3726,10 @@ export const JobsJob = message(
|
|
|
3319
3726
|
/** the last run a handler finished */
|
|
3320
3727
|
startedAt: [12, int],
|
|
3321
3728
|
endedAt: [13, int],
|
|
3729
|
+
/** where a job without an id lies, which a cancel names it by */
|
|
3730
|
+
row: [14, str],
|
|
3731
|
+
/** a walk's: why the job's value no longer reads, the job left out */
|
|
3732
|
+
failure: [15, Failure],
|
|
3322
3733
|
},
|
|
3323
3734
|
{
|
|
3324
3735
|
write(w, v) {
|
|
@@ -3389,6 +3800,16 @@ export const JobsJob = message(
|
|
|
3389
3800
|
w.int(v.endedAt)
|
|
3390
3801
|
n++
|
|
3391
3802
|
}
|
|
3803
|
+
if (v.row !== undefined) {
|
|
3804
|
+
w.field(14)
|
|
3805
|
+
w.str(v.row)
|
|
3806
|
+
n++
|
|
3807
|
+
}
|
|
3808
|
+
if (v.failure !== undefined) {
|
|
3809
|
+
w.field(15)
|
|
3810
|
+
Failure.write(w, v.failure)
|
|
3811
|
+
n++
|
|
3812
|
+
}
|
|
3392
3813
|
w.closeMap(head, n)
|
|
3393
3814
|
},
|
|
3394
3815
|
read(r) {
|
|
@@ -3405,6 +3826,8 @@ export const JobsJob = message(
|
|
|
3405
3826
|
let $repeat: string | undefined
|
|
3406
3827
|
let $startedAt: number | undefined
|
|
3407
3828
|
let $endedAt: number | undefined
|
|
3829
|
+
let $row: string | undefined
|
|
3830
|
+
let $failure: Read<typeof Failure.fields> | undefined
|
|
3408
3831
|
for (let n = r.message(); n > 0; n--) {
|
|
3409
3832
|
switch (r.field()) {
|
|
3410
3833
|
case 1:
|
|
@@ -3446,6 +3869,12 @@ export const JobsJob = message(
|
|
|
3446
3869
|
case 13:
|
|
3447
3870
|
$endedAt = r.int()
|
|
3448
3871
|
break
|
|
3872
|
+
case 14:
|
|
3873
|
+
$row = r.str()
|
|
3874
|
+
break
|
|
3875
|
+
case 15:
|
|
3876
|
+
$failure = Failure.read(r)
|
|
3877
|
+
break
|
|
3449
3878
|
default:
|
|
3450
3879
|
r.skip()
|
|
3451
3880
|
}
|
|
@@ -3465,6 +3894,8 @@ export const JobsJob = message(
|
|
|
3465
3894
|
repeat: $repeat,
|
|
3466
3895
|
startedAt: $startedAt,
|
|
3467
3896
|
endedAt: $endedAt,
|
|
3897
|
+
row: $row,
|
|
3898
|
+
failure: $failure,
|
|
3468
3899
|
}
|
|
3469
3900
|
},
|
|
3470
3901
|
},
|
|
@@ -3487,6 +3918,8 @@ export const JobsList = message(
|
|
|
3487
3918
|
after: [4, str],
|
|
3488
3919
|
/** 100 when absent, 1000 at most */
|
|
3489
3920
|
limit: [5, uint],
|
|
3921
|
+
/** a job whose value no longer reads comes as its failure in its place, not the page's */
|
|
3922
|
+
walk: [6, bool],
|
|
3490
3923
|
},
|
|
3491
3924
|
{
|
|
3492
3925
|
write(w, v) {
|
|
@@ -3517,6 +3950,11 @@ export const JobsList = message(
|
|
|
3517
3950
|
w.uint(v.limit)
|
|
3518
3951
|
n++
|
|
3519
3952
|
}
|
|
3953
|
+
if (v.walk !== undefined) {
|
|
3954
|
+
w.field(6)
|
|
3955
|
+
w.bool(v.walk)
|
|
3956
|
+
n++
|
|
3957
|
+
}
|
|
3520
3958
|
w.closeMap(head, n)
|
|
3521
3959
|
},
|
|
3522
3960
|
read(r) {
|
|
@@ -3525,6 +3963,7 @@ export const JobsList = message(
|
|
|
3525
3963
|
let $state: string | undefined
|
|
3526
3964
|
let $after: string | undefined
|
|
3527
3965
|
let $limit: number | undefined
|
|
3966
|
+
let $walk: boolean | undefined
|
|
3528
3967
|
for (let n = r.message(); n > 0; n--) {
|
|
3529
3968
|
switch (r.field()) {
|
|
3530
3969
|
case 1:
|
|
@@ -3542,12 +3981,22 @@ export const JobsList = message(
|
|
|
3542
3981
|
case 5:
|
|
3543
3982
|
$limit = r.uint()
|
|
3544
3983
|
break
|
|
3984
|
+
case 6:
|
|
3985
|
+
$walk = r.bool()
|
|
3986
|
+
break
|
|
3545
3987
|
default:
|
|
3546
3988
|
r.skip()
|
|
3547
3989
|
}
|
|
3548
3990
|
}
|
|
3549
3991
|
r.leave()
|
|
3550
|
-
return {
|
|
3992
|
+
return {
|
|
3993
|
+
handle: $handle,
|
|
3994
|
+
prefix: $prefix,
|
|
3995
|
+
state: $state,
|
|
3996
|
+
after: $after,
|
|
3997
|
+
limit: $limit,
|
|
3998
|
+
walk: $walk,
|
|
3999
|
+
}
|
|
3551
4000
|
},
|
|
3552
4001
|
},
|
|
3553
4002
|
)
|
|
@@ -3604,6 +4053,76 @@ export const JobsPage = message(
|
|
|
3604
4053
|
},
|
|
3605
4054
|
)
|
|
3606
4055
|
|
|
4056
|
+
/**
|
|
4057
|
+
* How many jobs a queue holds in each state, from one snapshot; a done job
|
|
4058
|
+
* has left it.
|
|
4059
|
+
*/
|
|
4060
|
+
export const JobsCounts = message(
|
|
4061
|
+
'jobs.Counts',
|
|
4062
|
+
{
|
|
4063
|
+
/** due later */
|
|
4064
|
+
scheduled: [1, uint],
|
|
4065
|
+
/** due, and no handler runs it yet */
|
|
4066
|
+
waiting: [2, uint],
|
|
4067
|
+
running: [3, uint],
|
|
4068
|
+
/** kept for the queue's keep */
|
|
4069
|
+
failed: [4, uint],
|
|
4070
|
+
},
|
|
4071
|
+
{
|
|
4072
|
+
write(w, v) {
|
|
4073
|
+
const head = w.openMap()
|
|
4074
|
+
let n = 0
|
|
4075
|
+
if (v.scheduled !== undefined) {
|
|
4076
|
+
w.field(1)
|
|
4077
|
+
w.uint(v.scheduled)
|
|
4078
|
+
n++
|
|
4079
|
+
}
|
|
4080
|
+
if (v.waiting !== undefined) {
|
|
4081
|
+
w.field(2)
|
|
4082
|
+
w.uint(v.waiting)
|
|
4083
|
+
n++
|
|
4084
|
+
}
|
|
4085
|
+
if (v.running !== undefined) {
|
|
4086
|
+
w.field(3)
|
|
4087
|
+
w.uint(v.running)
|
|
4088
|
+
n++
|
|
4089
|
+
}
|
|
4090
|
+
if (v.failed !== undefined) {
|
|
4091
|
+
w.field(4)
|
|
4092
|
+
w.uint(v.failed)
|
|
4093
|
+
n++
|
|
4094
|
+
}
|
|
4095
|
+
w.closeMap(head, n)
|
|
4096
|
+
},
|
|
4097
|
+
read(r) {
|
|
4098
|
+
let $scheduled: number | undefined
|
|
4099
|
+
let $waiting: number | undefined
|
|
4100
|
+
let $running: number | undefined
|
|
4101
|
+
let $failed: number | undefined
|
|
4102
|
+
for (let n = r.message(); n > 0; n--) {
|
|
4103
|
+
switch (r.field()) {
|
|
4104
|
+
case 1:
|
|
4105
|
+
$scheduled = r.uint()
|
|
4106
|
+
break
|
|
4107
|
+
case 2:
|
|
4108
|
+
$waiting = r.uint()
|
|
4109
|
+
break
|
|
4110
|
+
case 3:
|
|
4111
|
+
$running = r.uint()
|
|
4112
|
+
break
|
|
4113
|
+
case 4:
|
|
4114
|
+
$failed = r.uint()
|
|
4115
|
+
break
|
|
4116
|
+
default:
|
|
4117
|
+
r.skip()
|
|
4118
|
+
}
|
|
4119
|
+
}
|
|
4120
|
+
r.leave()
|
|
4121
|
+
return { scheduled: $scheduled, waiting: $waiting, running: $running, failed: $failed }
|
|
4122
|
+
},
|
|
4123
|
+
},
|
|
4124
|
+
)
|
|
4125
|
+
|
|
3607
4126
|
/**
|
|
3608
4127
|
* Starts the queue's worker for the client: the server claims its jobs as they
|
|
3609
4128
|
* fall due and hands each over as a held job, no more at once than the
|
|
@@ -3972,7 +4491,7 @@ export const JobsKept = message(
|
|
|
3972
4491
|
|
|
3973
4492
|
/**
|
|
3974
4493
|
* One write of a transaction: an add, a set or an update with its call, or a
|
|
3975
|
-
* cancel with its id.
|
|
4494
|
+
* cancel with its id or its row.
|
|
3976
4495
|
*/
|
|
3977
4496
|
export const JobsOp = message(
|
|
3978
4497
|
'jobs.Op',
|
|
@@ -6292,6 +6811,8 @@ export const MetricsAggregateAsked = message(
|
|
|
6292
6811
|
calendar: [7, str],
|
|
6293
6812
|
/** an IANA name, UTC among them, which calendar takes */
|
|
6294
6813
|
timeZone: [8, str],
|
|
6814
|
+
/** a NaN sample counts in no bucket, which says how many it passed over: skipped */
|
|
6815
|
+
skipNan: [9, bool],
|
|
6295
6816
|
},
|
|
6296
6817
|
{
|
|
6297
6818
|
write(w, v) {
|
|
@@ -6343,6 +6864,11 @@ export const MetricsAggregateAsked = message(
|
|
|
6343
6864
|
w.str(v.timeZone)
|
|
6344
6865
|
n++
|
|
6345
6866
|
}
|
|
6867
|
+
if (v.skipNan !== undefined) {
|
|
6868
|
+
w.field(9)
|
|
6869
|
+
w.bool(v.skipNan)
|
|
6870
|
+
n++
|
|
6871
|
+
}
|
|
6346
6872
|
w.closeMap(head, n)
|
|
6347
6873
|
},
|
|
6348
6874
|
read(r) {
|
|
@@ -6354,6 +6880,7 @@ export const MetricsAggregateAsked = message(
|
|
|
6354
6880
|
let $estimate: boolean | undefined
|
|
6355
6881
|
let $calendar: string | undefined
|
|
6356
6882
|
let $timeZone: string | undefined
|
|
6883
|
+
let $skipNan: boolean | undefined
|
|
6357
6884
|
for (let n = r.message(); n > 0; n--) {
|
|
6358
6885
|
switch (r.field()) {
|
|
6359
6886
|
case 1:
|
|
@@ -6392,6 +6919,9 @@ export const MetricsAggregateAsked = message(
|
|
|
6392
6919
|
case 8:
|
|
6393
6920
|
$timeZone = r.str()
|
|
6394
6921
|
break
|
|
6922
|
+
case 9:
|
|
6923
|
+
$skipNan = r.bool()
|
|
6924
|
+
break
|
|
6395
6925
|
default:
|
|
6396
6926
|
r.skip()
|
|
6397
6927
|
}
|
|
@@ -6406,6 +6936,7 @@ export const MetricsAggregateAsked = message(
|
|
|
6406
6936
|
estimate: $estimate,
|
|
6407
6937
|
calendar: $calendar,
|
|
6408
6938
|
timeZone: $timeZone,
|
|
6939
|
+
skipNan: $skipNan,
|
|
6409
6940
|
}
|
|
6410
6941
|
},
|
|
6411
6942
|
},
|
|
@@ -6431,6 +6962,8 @@ export const MetricsBucket = message(
|
|
|
6431
6962
|
partial: [8, bool],
|
|
6432
6963
|
/** its first step began before the bucket before it */
|
|
6433
6964
|
gap: [9, bool],
|
|
6965
|
+
/** the NaN samples it passed over, with skipNan */
|
|
6966
|
+
skipped: [10, uint],
|
|
6434
6967
|
},
|
|
6435
6968
|
{
|
|
6436
6969
|
write(w, v) {
|
|
@@ -6481,6 +7014,11 @@ export const MetricsBucket = message(
|
|
|
6481
7014
|
w.bool(v.gap)
|
|
6482
7015
|
n++
|
|
6483
7016
|
}
|
|
7017
|
+
if (v.skipped !== undefined) {
|
|
7018
|
+
w.field(10)
|
|
7019
|
+
w.uint(v.skipped)
|
|
7020
|
+
n++
|
|
7021
|
+
}
|
|
6484
7022
|
w.closeMap(head, n)
|
|
6485
7023
|
},
|
|
6486
7024
|
read(r) {
|
|
@@ -6493,6 +7031,7 @@ export const MetricsBucket = message(
|
|
|
6493
7031
|
let $resets: number | undefined
|
|
6494
7032
|
let $partial: boolean | undefined
|
|
6495
7033
|
let $gap: boolean | undefined
|
|
7034
|
+
let $skipped: number | undefined
|
|
6496
7035
|
for (let n = r.message(); n > 0; n--) {
|
|
6497
7036
|
switch (r.field()) {
|
|
6498
7037
|
case 1:
|
|
@@ -6522,6 +7061,9 @@ export const MetricsBucket = message(
|
|
|
6522
7061
|
case 9:
|
|
6523
7062
|
$gap = r.bool()
|
|
6524
7063
|
break
|
|
7064
|
+
case 10:
|
|
7065
|
+
$skipped = r.uint()
|
|
7066
|
+
break
|
|
6525
7067
|
default:
|
|
6526
7068
|
r.skip()
|
|
6527
7069
|
}
|
|
@@ -6537,6 +7079,7 @@ export const MetricsBucket = message(
|
|
|
6537
7079
|
resets: $resets,
|
|
6538
7080
|
partial: $partial,
|
|
6539
7081
|
gap: $gap,
|
|
7082
|
+
skipped: $skipped,
|
|
6540
7083
|
}
|
|
6541
7084
|
},
|
|
6542
7085
|
},
|
|
@@ -11158,7 +11701,8 @@ export const SqlMigration = message(
|
|
|
11158
11701
|
|
|
11159
11702
|
/**
|
|
11160
11703
|
* Opens a database. Migrations, when given, are applied and checked; without
|
|
11161
|
-
* them the file opens as it is.
|
|
11704
|
+
* them the file opens as it is. One that backups leave out lies in local/
|
|
11705
|
+
* rather than sql/, and a name whose file lies in the other folder is invalid.
|
|
11162
11706
|
*/
|
|
11163
11707
|
export const SqlOpen = message(
|
|
11164
11708
|
'sql.Open',
|
|
@@ -11168,6 +11712,8 @@ export const SqlOpen = message(
|
|
|
11168
11712
|
migrations: [2, list(SqlMigration)],
|
|
11169
11713
|
/** full or os: how far its commits go before they return; the store's own when absent */
|
|
11170
11714
|
durability: [3, str],
|
|
11715
|
+
/** false: no backup takes it, nor any node; true when absent */
|
|
11716
|
+
backup: [4, bool],
|
|
11171
11717
|
},
|
|
11172
11718
|
{
|
|
11173
11719
|
write(w, v) {
|
|
@@ -11191,12 +11737,18 @@ export const SqlOpen = message(
|
|
|
11191
11737
|
w.str(v.durability)
|
|
11192
11738
|
n++
|
|
11193
11739
|
}
|
|
11740
|
+
if (v.backup !== undefined) {
|
|
11741
|
+
w.field(4)
|
|
11742
|
+
w.bool(v.backup)
|
|
11743
|
+
n++
|
|
11744
|
+
}
|
|
11194
11745
|
w.closeMap(head, n)
|
|
11195
11746
|
},
|
|
11196
11747
|
read(r) {
|
|
11197
11748
|
let $name: string | undefined
|
|
11198
11749
|
let $migrations: Read<typeof SqlMigration.fields>[] | undefined
|
|
11199
11750
|
let $durability: string | undefined
|
|
11751
|
+
let $backup: boolean | undefined
|
|
11200
11752
|
for (let n = r.message(); n > 0; n--) {
|
|
11201
11753
|
switch (r.field()) {
|
|
11202
11754
|
case 1:
|
|
@@ -11214,12 +11766,15 @@ export const SqlOpen = message(
|
|
|
11214
11766
|
case 3:
|
|
11215
11767
|
$durability = r.str()
|
|
11216
11768
|
break
|
|
11769
|
+
case 4:
|
|
11770
|
+
$backup = r.bool()
|
|
11771
|
+
break
|
|
11217
11772
|
default:
|
|
11218
11773
|
r.skip()
|
|
11219
11774
|
}
|
|
11220
11775
|
}
|
|
11221
11776
|
r.leave()
|
|
11222
|
-
return { name: $name, migrations: $migrations, durability: $durability }
|
|
11777
|
+
return { name: $name, migrations: $migrations, durability: $durability, backup: $backup }
|
|
11223
11778
|
},
|
|
11224
11779
|
},
|
|
11225
11780
|
)
|
|
@@ -11370,8 +11925,58 @@ export const SqlStatement = message(
|
|
|
11370
11925
|
)
|
|
11371
11926
|
|
|
11372
11927
|
/**
|
|
11373
|
-
*
|
|
11374
|
-
|
|
11928
|
+
* A column a statement's rows are ordered by, named as its rows name it.
|
|
11929
|
+
*/
|
|
11930
|
+
export const SqlOrder = message(
|
|
11931
|
+
'sql.Order',
|
|
11932
|
+
{
|
|
11933
|
+
column: [1, str],
|
|
11934
|
+
descending: [2, bool],
|
|
11935
|
+
},
|
|
11936
|
+
{
|
|
11937
|
+
write(w, v) {
|
|
11938
|
+
const head = w.openMap()
|
|
11939
|
+
let n = 0
|
|
11940
|
+
if (v.column !== undefined) {
|
|
11941
|
+
w.field(1)
|
|
11942
|
+
w.str(v.column)
|
|
11943
|
+
n++
|
|
11944
|
+
}
|
|
11945
|
+
if (v.descending !== undefined) {
|
|
11946
|
+
w.field(2)
|
|
11947
|
+
w.bool(v.descending)
|
|
11948
|
+
n++
|
|
11949
|
+
}
|
|
11950
|
+
w.closeMap(head, n)
|
|
11951
|
+
},
|
|
11952
|
+
read(r) {
|
|
11953
|
+
let $column: string | undefined
|
|
11954
|
+
let $descending: boolean | undefined
|
|
11955
|
+
for (let n = r.message(); n > 0; n--) {
|
|
11956
|
+
switch (r.field()) {
|
|
11957
|
+
case 1:
|
|
11958
|
+
$column = r.str()
|
|
11959
|
+
break
|
|
11960
|
+
case 2:
|
|
11961
|
+
$descending = r.bool()
|
|
11962
|
+
break
|
|
11963
|
+
default:
|
|
11964
|
+
r.skip()
|
|
11965
|
+
}
|
|
11966
|
+
}
|
|
11967
|
+
r.leave()
|
|
11968
|
+
return { column: $column, descending: $descending }
|
|
11969
|
+
},
|
|
11970
|
+
},
|
|
11971
|
+
)
|
|
11972
|
+
|
|
11973
|
+
/**
|
|
11974
|
+
* What a statement gives back: its rows, one row or none, one value, or each
|
|
11975
|
+
* row as the reader reads it. A write with returning runs on the writer, its
|
|
11976
|
+
* rows given once it is durable. Each reads one snapshot of five seconds at
|
|
11977
|
+
* most; with order, the columns its text orders its rows by, a unique one
|
|
11978
|
+
* last, it reads on past that after the last row it sent, and without it
|
|
11979
|
+
* fails limit there.
|
|
11375
11980
|
*/
|
|
11376
11981
|
export const SqlQuery = message(
|
|
11377
11982
|
'sql.Query',
|
|
@@ -11379,8 +11984,9 @@ export const SqlQuery = message(
|
|
|
11379
11984
|
handle: [1, uint],
|
|
11380
11985
|
text: [2, str],
|
|
11381
11986
|
values: [3, list(sqlValue)],
|
|
11382
|
-
/** all, one or
|
|
11987
|
+
/** all, one, scalar or each */
|
|
11383
11988
|
want: [4, str],
|
|
11989
|
+
order: [5, list(SqlOrder)],
|
|
11384
11990
|
},
|
|
11385
11991
|
{
|
|
11386
11992
|
write(w, v) {
|
|
@@ -11409,6 +12015,14 @@ export const SqlQuery = message(
|
|
|
11409
12015
|
w.str(v.want)
|
|
11410
12016
|
n++
|
|
11411
12017
|
}
|
|
12018
|
+
if (v.order !== undefined) {
|
|
12019
|
+
w.field(5)
|
|
12020
|
+
w.array(v.order.length)
|
|
12021
|
+
for (const item0 of v.order) {
|
|
12022
|
+
SqlOrder.write(w, item0)
|
|
12023
|
+
}
|
|
12024
|
+
n++
|
|
12025
|
+
}
|
|
11412
12026
|
w.closeMap(head, n)
|
|
11413
12027
|
},
|
|
11414
12028
|
read(r) {
|
|
@@ -11416,6 +12030,7 @@ export const SqlQuery = message(
|
|
|
11416
12030
|
let $text: string | undefined
|
|
11417
12031
|
let $values: (SqlValue | boolean)[] | undefined
|
|
11418
12032
|
let $want: string | undefined
|
|
12033
|
+
let $order: Read<typeof SqlOrder.fields>[] | undefined
|
|
11419
12034
|
for (let n = r.message(); n > 0; n--) {
|
|
11420
12035
|
switch (r.field()) {
|
|
11421
12036
|
case 1:
|
|
@@ -11436,12 +12051,21 @@ export const SqlQuery = message(
|
|
|
11436
12051
|
case 4:
|
|
11437
12052
|
$want = r.str()
|
|
11438
12053
|
break
|
|
12054
|
+
case 5: {
|
|
12055
|
+
const items0: Read<typeof SqlOrder.fields>[] = []
|
|
12056
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
12057
|
+
items0.push(SqlOrder.read(r))
|
|
12058
|
+
}
|
|
12059
|
+
r.leave()
|
|
12060
|
+
$order = items0
|
|
12061
|
+
break
|
|
12062
|
+
}
|
|
11439
12063
|
default:
|
|
11440
12064
|
r.skip()
|
|
11441
12065
|
}
|
|
11442
12066
|
}
|
|
11443
12067
|
r.leave()
|
|
11444
|
-
return { handle: $handle, text: $text, values: $values, want: $want }
|
|
12068
|
+
return { handle: $handle, text: $text, values: $values, want: $want, order: $order }
|
|
11445
12069
|
},
|
|
11446
12070
|
},
|
|
11447
12071
|
)
|