baja-lite 1.4.3 → 1.4.4
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/package.json +1 -1
- package/sql.d.ts +68 -8
- package/sql.js +68 -8
package/package.json
CHANGED
package/sql.d.ts
CHANGED
|
@@ -1368,232 +1368,281 @@ declare class StreamQuery<T extends object> {
|
|
|
1368
1368
|
reset(): this;
|
|
1369
1369
|
/** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
|
|
1370
1370
|
if(condition: boolean): this;
|
|
1371
|
+
/**
|
|
1372
|
+
* AND(key1 = :value OR key2 = :value)
|
|
1373
|
+
* @param keys [key1, key2, ...]
|
|
1374
|
+
*/
|
|
1371
1375
|
eqs(keys: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1372
1376
|
paramName?: string | undefined;
|
|
1373
1377
|
skipEmptyString?: boolean | undefined;
|
|
1374
1378
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1375
1379
|
}): this;
|
|
1380
|
+
/*** AND key = :value */
|
|
1376
1381
|
eq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1377
1382
|
paramName?: string | undefined;
|
|
1378
1383
|
skipEmptyString?: boolean | undefined;
|
|
1379
1384
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1380
1385
|
}): this;
|
|
1386
|
+
/*** AND key1 = :value1 AND key2 = :value2 */
|
|
1381
1387
|
eqT(t: Partial<T>, { name: paramName, breakExcuteIfSkip }?: {
|
|
1382
1388
|
name?: string | undefined;
|
|
1383
1389
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1384
1390
|
}): this;
|
|
1391
|
+
/*** AND key <> :value */
|
|
1385
1392
|
notEq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1386
1393
|
paramName?: string | undefined;
|
|
1387
1394
|
skipEmptyString?: boolean | undefined;
|
|
1388
1395
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1389
1396
|
}): this;
|
|
1397
|
+
/** AND key1 = key2 */
|
|
1390
1398
|
eqWith(key1: keyof T, key2: keyof T): this;
|
|
1399
|
+
/** AND key1 <> key2 */
|
|
1391
1400
|
notEqWith(key1: keyof T, key2: keyof T): this;
|
|
1401
|
+
/** AND key REGEXP :regexp */
|
|
1392
1402
|
regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
|
|
1393
1403
|
paramName?: string | undefined;
|
|
1394
1404
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1395
1405
|
}): this;
|
|
1406
|
+
/** AND key NOT REGEXP :regexp */
|
|
1396
1407
|
notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
|
|
1397
1408
|
paramName?: string | undefined;
|
|
1398
1409
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1399
1410
|
}): this;
|
|
1400
|
-
/** (key1 << 8) + key2 = value */
|
|
1411
|
+
/** AND (key1 << 8) + key2 = value */
|
|
1401
1412
|
shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
|
|
1402
1413
|
paramName?: string | undefined;
|
|
1403
1414
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1404
1415
|
}): this;
|
|
1405
|
-
/** (key1 << 8) + key2 <> value */
|
|
1416
|
+
/** AND (key1 << 8) + key2 <> value */
|
|
1406
1417
|
shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
|
|
1407
1418
|
paramName?: string | undefined;
|
|
1408
1419
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1409
1420
|
}): this;
|
|
1421
|
+
/** AND key > :value */
|
|
1410
1422
|
grate(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
|
|
1411
1423
|
paramName?: string | undefined;
|
|
1412
1424
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1413
1425
|
}): this;
|
|
1426
|
+
/** AND key >= :value */
|
|
1414
1427
|
grateEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
|
|
1415
1428
|
paramName?: string | undefined;
|
|
1416
1429
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1417
1430
|
}): this;
|
|
1431
|
+
/** AND key1 > key2 */
|
|
1418
1432
|
grateWith(key1: keyof T, key2: keyof T): this;
|
|
1433
|
+
/** AND key1 >= key2 */
|
|
1419
1434
|
grateEqWith(key1: keyof T, key2: keyof T): this;
|
|
1435
|
+
/** AND key < :value */
|
|
1420
1436
|
less(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
|
|
1421
1437
|
paramName?: string | undefined;
|
|
1422
1438
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1423
1439
|
}): this;
|
|
1440
|
+
/** AND key <= :value */
|
|
1424
1441
|
lessEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
|
|
1425
1442
|
paramName?: string | undefined;
|
|
1426
1443
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1427
1444
|
}): this;
|
|
1445
|
+
/** AND key1 < key2 */
|
|
1428
1446
|
lessWith(key1: keyof T, key2: keyof T): this;
|
|
1447
|
+
/** AND key1 <= key2 */
|
|
1429
1448
|
lessEqWith(key1: keyof T, key2: keyof T): this;
|
|
1449
|
+
/** AND key LIKE CONCAT('%', :value, '%') */
|
|
1430
1450
|
like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1431
1451
|
paramName?: string | undefined;
|
|
1432
1452
|
skipEmptyString?: boolean | undefined;
|
|
1433
1453
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1434
1454
|
}): this;
|
|
1455
|
+
/** AND key NOT LIKE CONCAT('%', :value, '%') */
|
|
1435
1456
|
notLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1436
1457
|
paramName?: string | undefined;
|
|
1437
1458
|
skipEmptyString?: boolean | undefined;
|
|
1438
1459
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1439
1460
|
}): this;
|
|
1461
|
+
/** AND key NOT LIKE CONCAT('%', :value) */
|
|
1440
1462
|
leftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1441
1463
|
paramName?: string | undefined;
|
|
1442
1464
|
skipEmptyString?: boolean | undefined;
|
|
1443
1465
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1444
1466
|
}): this;
|
|
1467
|
+
/** AND key LIKE CONCAT('%', :value) */
|
|
1445
1468
|
notLeftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1446
1469
|
paramName?: string | undefined;
|
|
1447
1470
|
skipEmptyString?: boolean | undefined;
|
|
1448
1471
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1449
1472
|
}): this;
|
|
1473
|
+
/** AND key LIKE CONCAT(:value, '%') */
|
|
1450
1474
|
rightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1451
1475
|
paramName?: string | undefined;
|
|
1452
1476
|
skipEmptyString?: boolean | undefined;
|
|
1453
1477
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1454
1478
|
}): this;
|
|
1479
|
+
/** AND key NOT LIKE CONCAT(:value, '%') */
|
|
1455
1480
|
notRightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1456
1481
|
paramName?: string | undefined;
|
|
1457
1482
|
skipEmptyString?: boolean | undefined;
|
|
1458
1483
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1459
1484
|
}): this;
|
|
1485
|
+
/** AND key NOT LIKE :value */
|
|
1460
1486
|
PreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1461
1487
|
paramName?: string | undefined;
|
|
1462
1488
|
skipEmptyString?: boolean | undefined;
|
|
1463
1489
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1464
1490
|
}): this;
|
|
1491
|
+
/** AND key LIKE :value */
|
|
1465
1492
|
notPreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1466
1493
|
paramName?: string | undefined;
|
|
1467
1494
|
skipEmptyString?: boolean | undefined;
|
|
1468
1495
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1469
1496
|
}): this;
|
|
1497
|
+
/** AND key GLOB CONCAT('%', :value, '%') */
|
|
1470
1498
|
glob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1471
1499
|
paramName?: string | undefined;
|
|
1472
1500
|
skipEmptyString?: boolean | undefined;
|
|
1473
1501
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1474
1502
|
}): this;
|
|
1503
|
+
/** AND key NOT GLOB CONCAT('%', :value, '%') */
|
|
1475
1504
|
notGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1476
1505
|
paramName?: string | undefined;
|
|
1477
1506
|
skipEmptyString?: boolean | undefined;
|
|
1478
1507
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1479
1508
|
}): this;
|
|
1509
|
+
/** AND key GLOB CONCAT('%', :value) */
|
|
1480
1510
|
leftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1481
1511
|
paramName?: string | undefined;
|
|
1482
1512
|
skipEmptyString?: boolean | undefined;
|
|
1483
1513
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1484
1514
|
}): this;
|
|
1515
|
+
/** AND key NOT GLOB CONCAT('%', :value) */
|
|
1485
1516
|
notLeftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1486
1517
|
paramName?: string | undefined;
|
|
1487
1518
|
skipEmptyString?: boolean | undefined;
|
|
1488
1519
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1489
1520
|
}): this;
|
|
1521
|
+
/** AND key GLOB CONCAT(:value, '%') */
|
|
1490
1522
|
rightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1491
1523
|
paramName?: string | undefined;
|
|
1492
1524
|
skipEmptyString?: boolean | undefined;
|
|
1493
1525
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1494
1526
|
}): this;
|
|
1527
|
+
/** AND key NOT GLOB CONCAT(:value, '%') */
|
|
1495
1528
|
notRightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1496
1529
|
paramName?: string | undefined;
|
|
1497
1530
|
skipEmptyString?: boolean | undefined;
|
|
1498
1531
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1499
1532
|
}): this;
|
|
1533
|
+
/** AND key GLOB :value */
|
|
1500
1534
|
PreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1501
1535
|
paramName?: string | undefined;
|
|
1502
1536
|
skipEmptyString?: boolean | undefined;
|
|
1503
1537
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1504
1538
|
}): this;
|
|
1539
|
+
/** AND key NOT GLOB :value */
|
|
1505
1540
|
notPreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1506
1541
|
paramName?: string | undefined;
|
|
1507
1542
|
skipEmptyString?: boolean | undefined;
|
|
1508
1543
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1509
1544
|
}): this;
|
|
1545
|
+
/** AND key IN :value */
|
|
1510
1546
|
in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfSkip }?: {
|
|
1511
1547
|
paramName?: string | undefined;
|
|
1512
1548
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1513
1549
|
}): this;
|
|
1550
|
+
/** AND key NOT IN :value */
|
|
1514
1551
|
notIn(key: keyof T, value: Array<string | number>, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1515
1552
|
paramName?: string | undefined;
|
|
1516
1553
|
skipEmptyString?: boolean | undefined;
|
|
1517
1554
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1518
1555
|
}): this;
|
|
1556
|
+
/** AND :value IN (key1, key2, ...) */
|
|
1519
1557
|
in2(key: (keyof T)[], value: string | number, { paramName, breakExcuteIfSkip }?: {
|
|
1520
1558
|
paramName?: string | undefined;
|
|
1521
1559
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1522
1560
|
}): this;
|
|
1561
|
+
/** AND :value NOT IN (key1, key2, ...) */
|
|
1523
1562
|
notIn2(key: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1524
1563
|
paramName?: string | undefined;
|
|
1525
1564
|
skipEmptyString?: boolean | undefined;
|
|
1526
1565
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1527
1566
|
}): this;
|
|
1567
|
+
/** AND key IS NULL */
|
|
1528
1568
|
isNULL(key: keyof T): this;
|
|
1569
|
+
/** AND key IS NOT NULL */
|
|
1529
1570
|
isNotNULL(key: keyof T): this;
|
|
1571
|
+
/** AND key BETWEEN :value1 AND :value2 */
|
|
1530
1572
|
between(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1531
1573
|
paramName?: string | undefined;
|
|
1532
1574
|
skipEmptyString?: boolean | undefined;
|
|
1533
1575
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1534
1576
|
}): this;
|
|
1577
|
+
/** AND key NOT BETWEEN :value1 AND :value2 */
|
|
1535
1578
|
notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1536
1579
|
paramName?: string | undefined;
|
|
1537
1580
|
skipEmptyString?: boolean | undefined;
|
|
1538
1581
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1539
1582
|
}): this;
|
|
1583
|
+
/** AND POW(2, key) & :value */
|
|
1540
1584
|
pow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
|
|
1541
1585
|
paramName?: string | undefined;
|
|
1542
1586
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1543
1587
|
}): this;
|
|
1588
|
+
/** AND NOT POW(2, key) & :value */
|
|
1544
1589
|
notPow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
|
|
1545
1590
|
paramName?: string | undefined;
|
|
1546
1591
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1547
1592
|
}): this;
|
|
1593
|
+
/** AND POW(2, key1) & key2 */
|
|
1548
1594
|
powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
|
|
1549
1595
|
paramName?: string | undefined;
|
|
1550
1596
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1551
1597
|
}): this;
|
|
1598
|
+
/** AND NOT POW(2, key1) & key2 */
|
|
1552
1599
|
notPowWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
|
|
1553
1600
|
paramName?: string | undefined;
|
|
1554
1601
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1555
1602
|
}): this;
|
|
1556
|
-
/** MATCH(key1, key2, key3) AGAINST (value) */
|
|
1603
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) */
|
|
1557
1604
|
match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1558
1605
|
paramName?: string | undefined;
|
|
1559
1606
|
skipEmptyString?: boolean | undefined;
|
|
1560
1607
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1561
1608
|
}): this;
|
|
1562
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) */
|
|
1609
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
|
|
1563
1610
|
notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1564
1611
|
paramName?: string | undefined;
|
|
1565
1612
|
skipEmptyString?: boolean | undefined;
|
|
1566
1613
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1567
1614
|
}): this;
|
|
1568
|
-
/** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
|
|
1615
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
|
|
1569
1616
|
matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1570
1617
|
paramName?: string | undefined;
|
|
1571
1618
|
skipEmptyString?: boolean | undefined;
|
|
1572
1619
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1573
1620
|
}): this;
|
|
1574
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
|
|
1621
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
|
|
1575
1622
|
notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1576
1623
|
paramName?: string | undefined;
|
|
1577
1624
|
skipEmptyString?: boolean | undefined;
|
|
1578
1625
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1579
1626
|
}): this;
|
|
1580
|
-
/** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
|
|
1627
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
|
|
1581
1628
|
matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1582
1629
|
paramName?: string | undefined;
|
|
1583
1630
|
skipEmptyString?: boolean | undefined;
|
|
1584
1631
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1585
1632
|
}): this;
|
|
1586
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
|
|
1633
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
|
|
1587
1634
|
notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1588
1635
|
paramName?: string | undefined;
|
|
1589
1636
|
skipEmptyString?: boolean | undefined;
|
|
1590
1637
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1591
1638
|
}): this;
|
|
1639
|
+
/** AND NOT LOCATE(key, :value) > 0 */
|
|
1592
1640
|
includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1593
1641
|
paramName?: string | undefined;
|
|
1594
1642
|
skipEmptyString?: boolean | undefined;
|
|
1595
1643
|
breakExcuteIfSkip?: boolean | undefined;
|
|
1596
1644
|
}): this;
|
|
1645
|
+
/** AND NOT LOCATE(key, :value) = 0 */
|
|
1597
1646
|
notIncludes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
|
|
1598
1647
|
paramName?: string | undefined;
|
|
1599
1648
|
skipEmptyString?: boolean | undefined;
|
|
@@ -1601,22 +1650,33 @@ declare class StreamQuery<T extends object> {
|
|
|
1601
1650
|
}): this;
|
|
1602
1651
|
and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
|
|
1603
1652
|
or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
|
|
1653
|
+
/** SET key = IFNULL(key, 0) + :value */
|
|
1604
1654
|
incr(key: keyof T, value?: number): this;
|
|
1655
|
+
/** GROUP BY key1, key2, ... */
|
|
1605
1656
|
groupBy(...keys: (keyof T)[]): this;
|
|
1657
|
+
/** GROUP BY key1, key2, ... */
|
|
1606
1658
|
groupBy2(...keys: string[]): this;
|
|
1659
|
+
/** ORDER BY key1 ASC, key2 ASC, ... */
|
|
1607
1660
|
asc(...keys: (keyof T)[]): this;
|
|
1661
|
+
/** ORDER BY key1 ASC, key2 ASC, ... */
|
|
1608
1662
|
asc2(...keys: string[]): this;
|
|
1663
|
+
/** ORDER BY key1 DESC, key2 DESC, ... */
|
|
1609
1664
|
desc(...keys: (keyof T)[]): this;
|
|
1665
|
+
/** ORDER BY key1 DESC, key2 DESC, ... */
|
|
1610
1666
|
desc2(...keys: string[]): this;
|
|
1667
|
+
/** LIMIT :startRow, :pageSize */
|
|
1611
1668
|
limit(startRow: number, pageSize: number): this;
|
|
1669
|
+
/** LIMIT ((:pageNumber || 1) - 1) * :pageSize, :pageSize */
|
|
1612
1670
|
page(pageNumber: number, pageSize: number): this;
|
|
1613
1671
|
distinct(on?: boolean): this;
|
|
1672
|
+
/** COUNT(DISTINCT key) */
|
|
1614
1673
|
countDistinct(key: keyof T, countName?: string): this;
|
|
1615
1674
|
count(countName?: string): this;
|
|
1616
1675
|
sum(key: keyof T, legName?: string, distinct?: boolean): this;
|
|
1617
1676
|
avg(key: keyof T, legName?: string, distinct?: boolean): this;
|
|
1618
1677
|
max(key: keyof T, legName?: string, distinct?: boolean): this;
|
|
1619
1678
|
min(key: keyof T, legName?: string, distinct?: boolean): this;
|
|
1679
|
+
/** GROUP_CONCAT([DISTINCT] key [ORDER BY :asc ASC] [ORDER BY :asc DESC] [SEPARATOR :separator]) */
|
|
1620
1680
|
groupConcat(key: keyof T, param?: {
|
|
1621
1681
|
distinct?: boolean;
|
|
1622
1682
|
separator?: string;
|
package/sql.js
CHANGED
|
@@ -3422,8 +3422,14 @@ class StreamQuery {
|
|
|
3422
3422
|
this.if_proceed = condition;
|
|
3423
3423
|
return this;
|
|
3424
3424
|
}
|
|
3425
|
+
/**
|
|
3426
|
+
* AND(key1 = :value OR key2 = :value)
|
|
3427
|
+
* @param keys [key1, key2, ...]
|
|
3428
|
+
*/
|
|
3425
3429
|
eqs(keys, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this.__(keys, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3430
|
+
/*** AND key = :value */
|
|
3426
3431
|
eq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3432
|
+
/*** AND key1 = :value1 AND key2 = :value2 */
|
|
3427
3433
|
eqT(t, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
|
|
3428
3434
|
let exe = false;
|
|
3429
3435
|
if (t) {
|
|
@@ -3461,64 +3467,107 @@ class StreamQuery {
|
|
|
3461
3467
|
}
|
|
3462
3468
|
return this;
|
|
3463
3469
|
}
|
|
3470
|
+
/*** AND key <> :value */
|
|
3464
3471
|
notEq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3472
|
+
/** AND key1 = key2 */
|
|
3465
3473
|
eqWith(key1, key2) { return this._key(key1, key2, '='); }
|
|
3474
|
+
/** AND key1 <> key2 */
|
|
3466
3475
|
notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
|
|
3476
|
+
/** AND key REGEXP :regexp */
|
|
3467
3477
|
regexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
|
|
3478
|
+
/** AND key NOT REGEXP :regexp */
|
|
3468
3479
|
notRegexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfSkip }); }
|
|
3469
|
-
/** (key1 << 8) + key2 = value */
|
|
3480
|
+
/** AND (key1 << 8) + key2 = value */
|
|
3470
3481
|
shiftEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfSkip }); }
|
|
3471
|
-
/** (key1 << 8) + key2 <> value */
|
|
3482
|
+
/** AND (key1 << 8) + key2 <> value */
|
|
3472
3483
|
shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfSkip }); }
|
|
3484
|
+
/** AND key > :value */
|
|
3473
3485
|
grate(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
|
|
3486
|
+
/** AND key >= :value */
|
|
3474
3487
|
grateEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
|
|
3488
|
+
/** AND key1 > key2 */
|
|
3475
3489
|
grateWith(key1, key2) { return this._key(key1, key2, '>'); }
|
|
3490
|
+
/** AND key1 >= key2 */
|
|
3476
3491
|
grateEqWith(key1, key2) { return this._key(key1, key2, '>='); }
|
|
3492
|
+
/** AND key < :value */
|
|
3477
3493
|
less(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
|
|
3494
|
+
/** AND key <= :value */
|
|
3478
3495
|
lessEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
|
|
3496
|
+
/** AND key1 < key2 */
|
|
3479
3497
|
lessWith(key1, key2) { return this._key(key1, key2, '<'); }
|
|
3498
|
+
/** AND key1 <= key2 */
|
|
3480
3499
|
lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
|
|
3500
|
+
/** AND key LIKE CONCAT('%', :value, '%') */
|
|
3481
3501
|
like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip }); }
|
|
3502
|
+
/** AND key NOT LIKE CONCAT('%', :value, '%') */
|
|
3482
3503
|
notLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip }); }
|
|
3504
|
+
/** AND key NOT LIKE CONCAT('%', :value) */
|
|
3483
3505
|
leftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip }); }
|
|
3506
|
+
/** AND key LIKE CONCAT('%', :value) */
|
|
3484
3507
|
notLeftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip }); }
|
|
3508
|
+
/** AND key LIKE CONCAT(:value, '%') */
|
|
3485
3509
|
rightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip }); }
|
|
3510
|
+
/** AND key NOT LIKE CONCAT(:value, '%') */
|
|
3486
3511
|
notRightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip }); }
|
|
3512
|
+
/** AND key NOT LIKE :value */
|
|
3487
3513
|
PreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3514
|
+
/** AND key LIKE :value */
|
|
3488
3515
|
notPreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3516
|
+
/** AND key GLOB CONCAT('%', :value, '%') */
|
|
3489
3517
|
glob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3518
|
+
/** AND key NOT GLOB CONCAT('%', :value, '%') */
|
|
3490
3519
|
notGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3520
|
+
/** AND key GLOB CONCAT('%', :value) */
|
|
3491
3521
|
leftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3522
|
+
/** AND key NOT GLOB CONCAT('%', :value) */
|
|
3492
3523
|
notLeftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3524
|
+
/** AND key GLOB CONCAT(:value, '%') */
|
|
3493
3525
|
rightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3526
|
+
/** AND key NOT GLOB CONCAT(:value, '%') */
|
|
3494
3527
|
notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3528
|
+
/** AND key GLOB :value */
|
|
3495
3529
|
PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3530
|
+
/** AND key NOT GLOB :value */
|
|
3496
3531
|
notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
|
|
3532
|
+
/** AND key IN :value */
|
|
3497
3533
|
in(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, breakExcuteIfSkip }); }
|
|
3534
|
+
/** AND key NOT IN :value */
|
|
3498
3535
|
notIn(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3536
|
+
/** AND :value IN (key1, key2, ...) */
|
|
3499
3537
|
in2(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, breakExcuteIfSkip }); }
|
|
3538
|
+
/** AND :value NOT IN (key1, key2, ...) */
|
|
3500
3539
|
notIn2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3540
|
+
/** AND key IS NULL */
|
|
3501
3541
|
isNULL(key) { return this._null(key); }
|
|
3542
|
+
/** AND key IS NOT NULL */
|
|
3502
3543
|
isNotNULL(key) { return this._null(key, 'NOT'); }
|
|
3544
|
+
/** AND key BETWEEN :value1 AND :value2 */
|
|
3503
3545
|
between(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3546
|
+
/** AND key NOT BETWEEN :value1 AND :value2 */
|
|
3504
3547
|
notBetween(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3548
|
+
/** AND POW(2, key) & :value */
|
|
3505
3549
|
pow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, breakExcuteIfSkip }); }
|
|
3550
|
+
/** AND NOT POW(2, key) & :value */
|
|
3506
3551
|
notPow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfSkip }); }
|
|
3552
|
+
/** AND POW(2, key1) & key2 */
|
|
3507
3553
|
powWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfSkip }); }
|
|
3554
|
+
/** AND NOT POW(2, key1) & key2 */
|
|
3508
3555
|
notPowWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfSkip }); }
|
|
3509
|
-
/** MATCH(key1, key2, key3) AGAINST (value) */
|
|
3556
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) */
|
|
3510
3557
|
match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3511
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) */
|
|
3558
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
|
|
3512
3559
|
notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3513
|
-
/** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
|
|
3560
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
|
|
3514
3561
|
matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'IN BOOLEAN MODE' }); }
|
|
3515
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
|
|
3562
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
|
|
3516
3563
|
notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
|
|
3517
|
-
/** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
|
|
3564
|
+
/** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
|
|
3518
3565
|
matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'WITH QUERY EXPANSION' }); }
|
|
3519
|
-
/** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
|
|
3566
|
+
/** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
|
|
3520
3567
|
notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
|
|
3568
|
+
/** AND NOT LOCATE(key, :value) > 0 */
|
|
3521
3569
|
includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
|
|
3570
|
+
/** AND NOT LOCATE(key, :value) = 0 */
|
|
3522
3571
|
notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
|
|
3523
3572
|
and(fn) {
|
|
3524
3573
|
if (fn instanceof StreamQuery) {
|
|
@@ -3546,6 +3595,7 @@ class StreamQuery {
|
|
|
3546
3595
|
}
|
|
3547
3596
|
return this;
|
|
3548
3597
|
}
|
|
3598
|
+
/** SET key = IFNULL(key, 0) + :value */
|
|
3549
3599
|
incr(key, value = 1) {
|
|
3550
3600
|
const pkey = `p${this._prefix}${this._index++}`;
|
|
3551
3601
|
const keyName = this[_fields][String(key)]?.C2();
|
|
@@ -3553,21 +3603,31 @@ class StreamQuery {
|
|
|
3553
3603
|
this._param[pkey] = value;
|
|
3554
3604
|
return this;
|
|
3555
3605
|
}
|
|
3606
|
+
/** GROUP BY key1, key2, ... */
|
|
3556
3607
|
groupBy(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
|
|
3608
|
+
/** GROUP BY key1, key2, ... */
|
|
3557
3609
|
groupBy2(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
|
|
3610
|
+
/** ORDER BY key1 ASC, key2 ASC, ... */
|
|
3558
3611
|
asc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
|
|
3612
|
+
/** ORDER BY key1 ASC, key2 ASC, ... */
|
|
3559
3613
|
asc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
|
|
3614
|
+
/** ORDER BY key1 DESC, key2 DESC, ... */
|
|
3560
3615
|
desc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} DESC`)); return this; }
|
|
3616
|
+
/** ORDER BY key1 DESC, key2 DESC, ... */
|
|
3561
3617
|
desc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
|
|
3618
|
+
/** LIMIT :startRow, :pageSize */
|
|
3562
3619
|
limit(startRow, pageSize) { this._startRow = startRow; this._pageSize = pageSize; return this; }
|
|
3620
|
+
/** LIMIT ((:pageNumber || 1) - 1) * :pageSize, :pageSize */
|
|
3563
3621
|
page(pageNumber, pageSize) { this._startRow = ((pageNumber || 1) - 1) * pageSize; this._pageSize = pageSize; return this; }
|
|
3564
3622
|
distinct(on = true) { this._distinct = on; return this; }
|
|
3623
|
+
/** COUNT(DISTINCT key) */
|
|
3565
3624
|
countDistinct(key, countName) { this._columns.push(`COUNT(DISTINCT ${this[_fields][String(key)]?.C2()}) ${countName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
|
|
3566
3625
|
count(countName) { this._columns.push(`COUNT(1) ${countName ?? 'ct'}`); return this; }
|
|
3567
3626
|
sum(key, legName, distinct) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
|
|
3568
3627
|
avg(key, legName, distinct) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
|
|
3569
3628
|
max(key, legName, distinct) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
|
|
3570
3629
|
min(key, legName, distinct) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
|
|
3630
|
+
/** GROUP_CONCAT([DISTINCT] key [ORDER BY :asc ASC] [ORDER BY :asc DESC] [SEPARATOR :separator]) */
|
|
3571
3631
|
groupConcat(key, param) {
|
|
3572
3632
|
this._columns.push(`GROUP_CONCAT(
|
|
3573
3633
|
${param && param.distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}
|