baja-lite 1.4.11 → 1.4.12

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.
Files changed (3) hide show
  1. package/package.json +1 -1
  2. package/sql.d.ts +92 -92
  3. package/sql.js +67 -67
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "baja-lite",
3
- "version": "1.4.11",
3
+ "version": "1.4.12",
4
4
  "description": "some util for self",
5
5
  "homepage": "https://github.com/void-soul/baja-lite",
6
6
  "repository": {
package/sql.d.ts CHANGED
@@ -1438,281 +1438,281 @@ declare class StreamQuery<T extends object> {
1438
1438
  * AND(key1 = :value OR key2 = :value)
1439
1439
  * @param keys [key1, key2, ...]
1440
1440
  */
1441
- eqs(keys: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1441
+ eqs(keys: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1442
1442
  paramName?: string | undefined;
1443
1443
  skipEmptyString?: boolean | undefined;
1444
- breakExcuteIfSkip?: boolean | undefined;
1444
+ breakExcuteIfEmpty?: boolean | undefined;
1445
1445
  }): this;
1446
1446
  /*** AND key = :value */
1447
- eq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1447
+ eq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1448
1448
  paramName?: string | undefined;
1449
1449
  skipEmptyString?: boolean | undefined;
1450
- breakExcuteIfSkip?: boolean | undefined;
1450
+ breakExcuteIfEmpty?: boolean | undefined;
1451
1451
  }): this;
1452
1452
  /*** AND key1 = :value1 AND key2 = :value2 */
1453
- eqT(t: Partial<T>, { name: paramName, breakExcuteIfSkip }?: {
1453
+ eqT(t: Partial<T>, { name: paramName, breakExcuteIfEmpty }?: {
1454
1454
  name?: string | undefined;
1455
- breakExcuteIfSkip?: boolean | undefined;
1455
+ breakExcuteIfEmpty?: boolean | undefined;
1456
1456
  }): this;
1457
1457
  /*** AND key <> :value */
1458
- notEq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1458
+ notEq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1459
1459
  paramName?: string | undefined;
1460
1460
  skipEmptyString?: boolean | undefined;
1461
- breakExcuteIfSkip?: boolean | undefined;
1461
+ breakExcuteIfEmpty?: boolean | undefined;
1462
1462
  }): this;
1463
1463
  /** AND key1 = key2 */
1464
1464
  eqWith(key1: keyof T, key2: keyof T): this;
1465
1465
  /** AND key1 <> key2 */
1466
1466
  notEqWith(key1: keyof T, key2: keyof T): this;
1467
1467
  /** AND key REGEXP :regexp */
1468
- regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
1468
+ regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
1469
1469
  paramName?: string | undefined;
1470
- breakExcuteIfSkip?: boolean | undefined;
1470
+ breakExcuteIfEmpty?: boolean | undefined;
1471
1471
  }): this;
1472
1472
  /** AND key NOT REGEXP :regexp */
1473
- notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
1473
+ notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
1474
1474
  paramName?: string | undefined;
1475
- breakExcuteIfSkip?: boolean | undefined;
1475
+ breakExcuteIfEmpty?: boolean | undefined;
1476
1476
  }): this;
1477
1477
  /** AND (key1 << 8) + key2 = value */
1478
- shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
1478
+ shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
1479
1479
  paramName?: string | undefined;
1480
- breakExcuteIfSkip?: boolean | undefined;
1480
+ breakExcuteIfEmpty?: boolean | undefined;
1481
1481
  }): this;
1482
1482
  /** AND (key1 << 8) + key2 <> value */
1483
- shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
1483
+ shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
1484
1484
  paramName?: string | undefined;
1485
- breakExcuteIfSkip?: boolean | undefined;
1485
+ breakExcuteIfEmpty?: boolean | undefined;
1486
1486
  }): this;
1487
1487
  /** AND key > :value */
1488
- grate(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
1488
+ grate(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
1489
1489
  paramName?: string | undefined;
1490
- breakExcuteIfSkip?: boolean | undefined;
1490
+ breakExcuteIfEmpty?: boolean | undefined;
1491
1491
  }): this;
1492
1492
  /** AND key >= :value */
1493
- grateEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
1493
+ grateEq(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
1494
1494
  paramName?: string | undefined;
1495
- breakExcuteIfSkip?: boolean | undefined;
1495
+ breakExcuteIfEmpty?: boolean | undefined;
1496
1496
  }): this;
1497
1497
  /** AND key1 > key2 */
1498
1498
  grateWith(key1: keyof T, key2: keyof T): this;
1499
1499
  /** AND key1 >= key2 */
1500
1500
  grateEqWith(key1: keyof T, key2: keyof T): this;
1501
1501
  /** AND key < :value */
1502
- less(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
1502
+ less(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
1503
1503
  paramName?: string | undefined;
1504
- breakExcuteIfSkip?: boolean | undefined;
1504
+ breakExcuteIfEmpty?: boolean | undefined;
1505
1505
  }): this;
1506
1506
  /** AND key <= :value */
1507
- lessEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
1507
+ lessEq(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
1508
1508
  paramName?: string | undefined;
1509
- breakExcuteIfSkip?: boolean | undefined;
1509
+ breakExcuteIfEmpty?: boolean | undefined;
1510
1510
  }): this;
1511
1511
  /** AND key1 < key2 */
1512
1512
  lessWith(key1: keyof T, key2: keyof T): this;
1513
1513
  /** AND key1 <= key2 */
1514
1514
  lessEqWith(key1: keyof T, key2: keyof T): this;
1515
1515
  /** AND key LIKE CONCAT('%', :value, '%') */
1516
- like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1516
+ like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1517
1517
  paramName?: string | undefined;
1518
1518
  skipEmptyString?: boolean | undefined;
1519
- breakExcuteIfSkip?: boolean | undefined;
1519
+ breakExcuteIfEmpty?: boolean | undefined;
1520
1520
  }): this;
1521
1521
  /** AND key NOT LIKE CONCAT('%', :value, '%') */
1522
- notLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1522
+ notLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1523
1523
  paramName?: string | undefined;
1524
1524
  skipEmptyString?: boolean | undefined;
1525
- breakExcuteIfSkip?: boolean | undefined;
1525
+ breakExcuteIfEmpty?: boolean | undefined;
1526
1526
  }): this;
1527
1527
  /** AND key NOT LIKE CONCAT('%', :value) */
1528
- leftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1528
+ leftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1529
1529
  paramName?: string | undefined;
1530
1530
  skipEmptyString?: boolean | undefined;
1531
- breakExcuteIfSkip?: boolean | undefined;
1531
+ breakExcuteIfEmpty?: boolean | undefined;
1532
1532
  }): this;
1533
1533
  /** AND key LIKE CONCAT('%', :value) */
1534
- notLeftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1534
+ notLeftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1535
1535
  paramName?: string | undefined;
1536
1536
  skipEmptyString?: boolean | undefined;
1537
- breakExcuteIfSkip?: boolean | undefined;
1537
+ breakExcuteIfEmpty?: boolean | undefined;
1538
1538
  }): this;
1539
1539
  /** AND key LIKE CONCAT(:value, '%') */
1540
- rightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1540
+ rightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1541
1541
  paramName?: string | undefined;
1542
1542
  skipEmptyString?: boolean | undefined;
1543
- breakExcuteIfSkip?: boolean | undefined;
1543
+ breakExcuteIfEmpty?: boolean | undefined;
1544
1544
  }): this;
1545
1545
  /** AND key NOT LIKE CONCAT(:value, '%') */
1546
- notRightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1546
+ notRightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1547
1547
  paramName?: string | undefined;
1548
1548
  skipEmptyString?: boolean | undefined;
1549
- breakExcuteIfSkip?: boolean | undefined;
1549
+ breakExcuteIfEmpty?: boolean | undefined;
1550
1550
  }): this;
1551
1551
  /** AND key NOT LIKE :value */
1552
- PreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1552
+ PreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1553
1553
  paramName?: string | undefined;
1554
1554
  skipEmptyString?: boolean | undefined;
1555
- breakExcuteIfSkip?: boolean | undefined;
1555
+ breakExcuteIfEmpty?: boolean | undefined;
1556
1556
  }): this;
1557
1557
  /** AND key LIKE :value */
1558
- notPreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1558
+ notPreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1559
1559
  paramName?: string | undefined;
1560
1560
  skipEmptyString?: boolean | undefined;
1561
- breakExcuteIfSkip?: boolean | undefined;
1561
+ breakExcuteIfEmpty?: boolean | undefined;
1562
1562
  }): this;
1563
1563
  /** AND key GLOB CONCAT('%', :value, '%') */
1564
- glob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1564
+ glob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1565
1565
  paramName?: string | undefined;
1566
1566
  skipEmptyString?: boolean | undefined;
1567
- breakExcuteIfSkip?: boolean | undefined;
1567
+ breakExcuteIfEmpty?: boolean | undefined;
1568
1568
  }): this;
1569
1569
  /** AND key NOT GLOB CONCAT('%', :value, '%') */
1570
- notGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1570
+ notGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1571
1571
  paramName?: string | undefined;
1572
1572
  skipEmptyString?: boolean | undefined;
1573
- breakExcuteIfSkip?: boolean | undefined;
1573
+ breakExcuteIfEmpty?: boolean | undefined;
1574
1574
  }): this;
1575
1575
  /** AND key GLOB CONCAT('%', :value) */
1576
- leftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1576
+ leftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1577
1577
  paramName?: string | undefined;
1578
1578
  skipEmptyString?: boolean | undefined;
1579
- breakExcuteIfSkip?: boolean | undefined;
1579
+ breakExcuteIfEmpty?: boolean | undefined;
1580
1580
  }): this;
1581
1581
  /** AND key NOT GLOB CONCAT('%', :value) */
1582
- notLeftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1582
+ notLeftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1583
1583
  paramName?: string | undefined;
1584
1584
  skipEmptyString?: boolean | undefined;
1585
- breakExcuteIfSkip?: boolean | undefined;
1585
+ breakExcuteIfEmpty?: boolean | undefined;
1586
1586
  }): this;
1587
1587
  /** AND key GLOB CONCAT(:value, '%') */
1588
- rightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1588
+ rightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1589
1589
  paramName?: string | undefined;
1590
1590
  skipEmptyString?: boolean | undefined;
1591
- breakExcuteIfSkip?: boolean | undefined;
1591
+ breakExcuteIfEmpty?: boolean | undefined;
1592
1592
  }): this;
1593
1593
  /** AND key NOT GLOB CONCAT(:value, '%') */
1594
- notRightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1594
+ notRightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1595
1595
  paramName?: string | undefined;
1596
1596
  skipEmptyString?: boolean | undefined;
1597
- breakExcuteIfSkip?: boolean | undefined;
1597
+ breakExcuteIfEmpty?: boolean | undefined;
1598
1598
  }): this;
1599
1599
  /** AND key GLOB :value */
1600
- PreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1600
+ PreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1601
1601
  paramName?: string | undefined;
1602
1602
  skipEmptyString?: boolean | undefined;
1603
- breakExcuteIfSkip?: boolean | undefined;
1603
+ breakExcuteIfEmpty?: boolean | undefined;
1604
1604
  }): this;
1605
1605
  /** AND key NOT GLOB :value */
1606
- notPreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1606
+ notPreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1607
1607
  paramName?: string | undefined;
1608
1608
  skipEmptyString?: boolean | undefined;
1609
- breakExcuteIfSkip?: boolean | undefined;
1609
+ breakExcuteIfEmpty?: boolean | undefined;
1610
1610
  }): this;
1611
1611
  /** AND key IN :value */
1612
- in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfSkip }?: {
1612
+ in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfEmpty }?: {
1613
1613
  paramName?: string | undefined;
1614
- breakExcuteIfSkip?: boolean | undefined;
1614
+ breakExcuteIfEmpty?: boolean | undefined;
1615
1615
  }): this;
1616
1616
  /** AND key NOT IN :value */
1617
- notIn(key: keyof T, value: Array<string | number>, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1617
+ notIn(key: keyof T, value: Array<string | number>, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1618
1618
  paramName?: string | undefined;
1619
1619
  skipEmptyString?: boolean | undefined;
1620
- breakExcuteIfSkip?: boolean | undefined;
1620
+ breakExcuteIfEmpty?: boolean | undefined;
1621
1621
  }): this;
1622
1622
  /** AND :value IN (key1, key2, ...) */
1623
- in2(key: (keyof T)[], value: string | number, { paramName, breakExcuteIfSkip }?: {
1623
+ in2(key: (keyof T)[], value: string | number, { paramName, breakExcuteIfEmpty }?: {
1624
1624
  paramName?: string | undefined;
1625
- breakExcuteIfSkip?: boolean | undefined;
1625
+ breakExcuteIfEmpty?: boolean | undefined;
1626
1626
  }): this;
1627
1627
  /** AND :value NOT IN (key1, key2, ...) */
1628
- notIn2(key: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1628
+ notIn2(key: (keyof T)[], value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1629
1629
  paramName?: string | undefined;
1630
1630
  skipEmptyString?: boolean | undefined;
1631
- breakExcuteIfSkip?: boolean | undefined;
1631
+ breakExcuteIfEmpty?: boolean | undefined;
1632
1632
  }): this;
1633
1633
  /** AND key IS NULL */
1634
1634
  isNULL(key: keyof T): this;
1635
1635
  /** AND key IS NOT NULL */
1636
1636
  isNotNULL(key: keyof T): this;
1637
1637
  /** AND key BETWEEN :value1 AND :value2 */
1638
- between(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1638
+ between(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1639
1639
  paramName?: string | undefined;
1640
1640
  skipEmptyString?: boolean | undefined;
1641
- breakExcuteIfSkip?: boolean | undefined;
1641
+ breakExcuteIfEmpty?: boolean | undefined;
1642
1642
  }): this;
1643
1643
  /** AND key NOT BETWEEN :value1 AND :value2 */
1644
- notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1644
+ notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1645
1645
  paramName?: string | undefined;
1646
1646
  skipEmptyString?: boolean | undefined;
1647
- breakExcuteIfSkip?: boolean | undefined;
1647
+ breakExcuteIfEmpty?: boolean | undefined;
1648
1648
  }): this;
1649
1649
  /** AND POW(2, key) & :value */
1650
- pow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
1650
+ pow(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
1651
1651
  paramName?: string | undefined;
1652
- breakExcuteIfSkip?: boolean | undefined;
1652
+ breakExcuteIfEmpty?: boolean | undefined;
1653
1653
  }): this;
1654
1654
  /** AND NOT POW(2, key) & :value */
1655
- notPow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
1655
+ notPow(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
1656
1656
  paramName?: string | undefined;
1657
- breakExcuteIfSkip?: boolean | undefined;
1657
+ breakExcuteIfEmpty?: boolean | undefined;
1658
1658
  }): this;
1659
1659
  /** AND POW(2, key1) & key2 */
1660
- powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
1660
+ powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfEmpty }?: {
1661
1661
  paramName?: string | undefined;
1662
- breakExcuteIfSkip?: boolean | undefined;
1662
+ breakExcuteIfEmpty?: boolean | undefined;
1663
1663
  }): this;
1664
1664
  /** AND NOT POW(2, key1) & key2 */
1665
- notPowWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
1665
+ notPowWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfEmpty }?: {
1666
1666
  paramName?: string | undefined;
1667
- breakExcuteIfSkip?: boolean | undefined;
1667
+ breakExcuteIfEmpty?: boolean | undefined;
1668
1668
  }): this;
1669
1669
  /** AND MATCH(key1, key2, key3) AGAINST (:value) */
1670
- match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1670
+ match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1671
1671
  paramName?: string | undefined;
1672
1672
  skipEmptyString?: boolean | undefined;
1673
- breakExcuteIfSkip?: boolean | undefined;
1673
+ breakExcuteIfEmpty?: boolean | undefined;
1674
1674
  }): this;
1675
1675
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
1676
- notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1676
+ notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1677
1677
  paramName?: string | undefined;
1678
1678
  skipEmptyString?: boolean | undefined;
1679
- breakExcuteIfSkip?: boolean | undefined;
1679
+ breakExcuteIfEmpty?: boolean | undefined;
1680
1680
  }): this;
1681
1681
  /** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
1682
- matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1682
+ matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1683
1683
  paramName?: string | undefined;
1684
1684
  skipEmptyString?: boolean | undefined;
1685
- breakExcuteIfSkip?: boolean | undefined;
1685
+ breakExcuteIfEmpty?: boolean | undefined;
1686
1686
  }): this;
1687
1687
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
1688
- notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1688
+ notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1689
1689
  paramName?: string | undefined;
1690
1690
  skipEmptyString?: boolean | undefined;
1691
- breakExcuteIfSkip?: boolean | undefined;
1691
+ breakExcuteIfEmpty?: boolean | undefined;
1692
1692
  }): this;
1693
1693
  /** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
1694
- matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1694
+ matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1695
1695
  paramName?: string | undefined;
1696
1696
  skipEmptyString?: boolean | undefined;
1697
- breakExcuteIfSkip?: boolean | undefined;
1697
+ breakExcuteIfEmpty?: boolean | undefined;
1698
1698
  }): this;
1699
1699
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
1700
- notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1700
+ notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1701
1701
  paramName?: string | undefined;
1702
1702
  skipEmptyString?: boolean | undefined;
1703
- breakExcuteIfSkip?: boolean | undefined;
1703
+ breakExcuteIfEmpty?: boolean | undefined;
1704
1704
  }): this;
1705
1705
  /** AND NOT LOCATE(key, :value) > 0 */
1706
- includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1706
+ includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1707
1707
  paramName?: string | undefined;
1708
1708
  skipEmptyString?: boolean | undefined;
1709
- breakExcuteIfSkip?: boolean | undefined;
1709
+ breakExcuteIfEmpty?: boolean | undefined;
1710
1710
  }): this;
1711
1711
  /** AND NOT LOCATE(key, :value) = 0 */
1712
- notIncludes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
1712
+ notIncludes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
1713
1713
  paramName?: string | undefined;
1714
1714
  skipEmptyString?: boolean | undefined;
1715
- breakExcuteIfSkip?: boolean | undefined;
1715
+ breakExcuteIfEmpty?: boolean | undefined;
1716
1716
  }): this;
1717
1717
  and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
1718
1718
  or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
package/sql.js CHANGED
@@ -3473,11 +3473,11 @@ class StreamQuery {
3473
3473
  * AND(key1 = :value OR key2 = :value)
3474
3474
  * @param keys [key1, key2, ...]
3475
3475
  */
3476
- eqs(keys, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this.__(keys, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
3476
+ eqs(keys, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this.__(keys, value, '=', { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3477
3477
  /*** AND key = :value */
3478
- eq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
3478
+ eq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3479
3479
  /*** AND key1 = :value1 AND key2 = :value2 */
3480
- eqT(t, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
3480
+ eqT(t, { name: paramName = '', breakExcuteIfEmpty = true } = {}) {
3481
3481
  let exe = false;
3482
3482
  if (t) {
3483
3483
  t = this._service[_transformer](t, {
@@ -3509,113 +3509,113 @@ class StreamQuery {
3509
3509
  exe = true;
3510
3510
  }
3511
3511
  }
3512
- if (breakExcuteIfSkip && exe === false) {
3512
+ if (breakExcuteIfEmpty && exe === false) {
3513
3513
  this.if_exec = false;
3514
3514
  }
3515
3515
  return this;
3516
3516
  }
3517
3517
  /*** AND key <> :value */
3518
- notEq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfSkip }); }
3518
+ notEq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3519
3519
  /** AND key1 = key2 */
3520
3520
  eqWith(key1, key2) { return this._key(key1, key2, '='); }
3521
3521
  /** AND key1 <> key2 */
3522
3522
  notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
3523
3523
  /** AND key REGEXP :regexp */
3524
- regexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
3524
+ regexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
3525
3525
  /** AND key NOT REGEXP :regexp */
3526
- notRegexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfSkip }); }
3526
+ notRegexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfEmpty }); }
3527
3527
  /** AND (key1 << 8) + key2 = value */
3528
- shiftEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfSkip }); }
3528
+ shiftEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfEmpty }); }
3529
3529
  /** AND (key1 << 8) + key2 <> value */
3530
- shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfSkip }); }
3530
+ shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfEmpty }); }
3531
3531
  /** AND key > :value */
3532
- grate(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
3532
+ grate(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
3533
3533
  /** AND key >= :value */
3534
- grateEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
3534
+ grateEq(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
3535
3535
  /** AND key1 > key2 */
3536
3536
  grateWith(key1, key2) { return this._key(key1, key2, '>'); }
3537
3537
  /** AND key1 >= key2 */
3538
3538
  grateEqWith(key1, key2) { return this._key(key1, key2, '>='); }
3539
3539
  /** AND key < :value */
3540
- less(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
3540
+ less(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
3541
3541
  /** AND key <= :value */
3542
- lessEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
3542
+ lessEq(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
3543
3543
  /** AND key1 < key2 */
3544
3544
  lessWith(key1, key2) { return this._key(key1, key2, '<'); }
3545
3545
  /** AND key1 <= key2 */
3546
3546
  lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
3547
3547
  /** AND key LIKE CONCAT('%', :value, '%') */
3548
- like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip }); }
3548
+ like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfEmpty }); }
3549
3549
  /** AND key NOT LIKE CONCAT('%', :value, '%') */
3550
- notLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip }); }
3550
+ notLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfEmpty }); }
3551
3551
  /** AND key NOT LIKE CONCAT('%', :value) */
3552
- leftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip }); }
3552
+ leftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfEmpty }); }
3553
3553
  /** AND key LIKE CONCAT('%', :value) */
3554
- notLeftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip }); }
3554
+ notLeftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfEmpty }); }
3555
3555
  /** AND key LIKE CONCAT(:value, '%') */
3556
- rightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip }); }
3556
+ rightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfEmpty }); }
3557
3557
  /** AND key NOT LIKE CONCAT(:value, '%') */
3558
- notRightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip }); }
3558
+ notRightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfEmpty }); }
3559
3559
  /** AND key NOT LIKE :value */
3560
- PreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
3560
+ PreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3561
3561
  /** AND key LIKE :value */
3562
- notPreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3562
+ notPreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3563
3563
  /** AND key GLOB CONCAT('%', :value, '%') */
3564
- glob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
3564
+ glob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
3565
3565
  /** AND key NOT GLOB CONCAT('%', :value, '%') */
3566
- notGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
3566
+ notGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
3567
3567
  /** AND key GLOB CONCAT('%', :value) */
3568
- leftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip, op: 'GLOB' }); }
3568
+ leftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
3569
3569
  /** AND key NOT GLOB CONCAT('%', :value) */
3570
- notLeftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
3570
+ notLeftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
3571
3571
  /** AND key GLOB CONCAT(:value, '%') */
3572
- rightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
3572
+ rightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
3573
3573
  /** AND key NOT GLOB CONCAT(:value, '%') */
3574
- notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
3574
+ notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
3575
3575
  /** AND key GLOB :value */
3576
- PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip, op: 'GLOB' }); }
3576
+ PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty, op: 'GLOB' }); }
3577
3577
  /** AND key NOT GLOB :value */
3578
- notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
3578
+ notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
3579
3579
  /** AND key IN :value */
3580
- in(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, breakExcuteIfSkip }); }
3580
+ in(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._in(key, value, { paramName, breakExcuteIfEmpty }); }
3581
3581
  /** AND key NOT IN :value */
3582
- notIn(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3582
+ notIn(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3583
3583
  /** AND :value IN (key1, key2, ...) */
3584
- in2(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, breakExcuteIfSkip }); }
3584
+ in2(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._in2(key, value, { paramName, breakExcuteIfEmpty }); }
3585
3585
  /** AND :value NOT IN (key1, key2, ...) */
3586
- notIn2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3586
+ notIn2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._in2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3587
3587
  /** AND key IS NULL */
3588
3588
  isNULL(key) { return this._null(key); }
3589
3589
  /** AND key IS NOT NULL */
3590
3590
  isNotNULL(key) { return this._null(key, 'NOT'); }
3591
3591
  /** AND key BETWEEN :value1 AND :value2 */
3592
- between(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfSkip }); }
3592
+ between(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3593
3593
  /** AND key NOT BETWEEN :value1 AND :value2 */
3594
- notBetween(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3594
+ notBetween(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3595
3595
  /** AND POW(2, key) & :value */
3596
- pow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, breakExcuteIfSkip }); }
3596
+ pow(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, value, { paramName, breakExcuteIfEmpty }); }
3597
3597
  /** AND NOT POW(2, key) & :value */
3598
- notPow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfSkip }); }
3598
+ notPow(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfEmpty }); }
3599
3599
  /** AND POW(2, key1) & key2 */
3600
- powWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfSkip }); }
3600
+ powWith(key, values, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfEmpty }); }
3601
3601
  /** AND NOT POW(2, key1) & key2 */
3602
- notPowWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfSkip }); }
3602
+ notPowWith(key, values, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfEmpty }); }
3603
3603
  /** AND MATCH(key1, key2, key3) AGAINST (:value) */
3604
- match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip }); }
3604
+ match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3605
3605
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
3606
- notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3606
+ notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3607
3607
  /** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
3608
- matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'IN BOOLEAN MODE' }); }
3608
+ matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, append: 'IN BOOLEAN MODE' }); }
3609
3609
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
3610
- notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
3610
+ notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
3611
3611
  /** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
3612
- matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'WITH QUERY EXPANSION' }); }
3612
+ matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, append: 'WITH QUERY EXPANSION' }); }
3613
3613
  /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
3614
- notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
3614
+ notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
3615
3615
  /** AND NOT LOCATE(key, :value) > 0 */
3616
- includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
3616
+ includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
3617
3617
  /** AND NOT LOCATE(key, :value) = 0 */
3618
- notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
3618
+ notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
3619
3619
  and(fn) {
3620
3620
  if (fn instanceof StreamQuery) {
3621
3621
  this._andQuerys.push(fn);
@@ -3902,11 +3902,11 @@ class StreamQuery {
3902
3902
  }
3903
3903
  return { where: wheres.join(' '), params: this._param };
3904
3904
  }
3905
- _(key, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
3905
+ _(key, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
3906
3906
  if (value === null
3907
3907
  || value === undefined
3908
3908
  || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
3909
- if (breakExcuteIfSkip) {
3909
+ if (breakExcuteIfEmpty) {
3910
3910
  this.if_exec = false;
3911
3911
  }
3912
3912
  return this;
@@ -3924,11 +3924,11 @@ class StreamQuery {
3924
3924
  }
3925
3925
  return this;
3926
3926
  }
3927
- __(keys, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
3927
+ __(keys, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
3928
3928
  if (value === null
3929
3929
  || value === undefined
3930
3930
  || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
3931
- if (breakExcuteIfSkip) {
3931
+ if (breakExcuteIfEmpty) {
3932
3932
  this.if_exec = false;
3933
3933
  }
3934
3934
  return this;
@@ -3954,14 +3954,14 @@ class StreamQuery {
3954
3954
  this._wheres.push(`AND ${this[_fields][String(key1)]?.C2()} ${not} ${op} ${this[_fields][String(key2)]?.C2()} `);
3955
3955
  return this;
3956
3956
  }
3957
- _between(key, value1, value2, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
3957
+ _between(key, value1, value2, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
3958
3958
  if (value1 === null
3959
3959
  || value1 === undefined
3960
3960
  || (emptyString(`${value1 ?? ''}`) && skipEmptyString)
3961
3961
  || value2 === null
3962
3962
  || value2 === undefined
3963
3963
  || (emptyString(`${value2 ?? ''}`) && skipEmptyString)) {
3964
- if (breakExcuteIfSkip) {
3964
+ if (breakExcuteIfEmpty) {
3965
3965
  this.if_exec = false;
3966
3966
  }
3967
3967
  return this;
@@ -3981,7 +3981,7 @@ class StreamQuery {
3981
3981
  }
3982
3982
  return this;
3983
3983
  }
3984
- _in(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
3984
+ _in(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
3985
3985
  if (value && value.length > 0 && skipEmptyString) {
3986
3986
  value = value.filter(v => !emptyString(`${v ?? ''}`));
3987
3987
  }
@@ -3998,12 +3998,12 @@ class StreamQuery {
3998
3998
  }
3999
3999
  }
4000
4000
  }
4001
- else if (breakExcuteIfSkip !== true) {
4001
+ else if (breakExcuteIfEmpty) {
4002
4002
  this.if_exec = false;
4003
4003
  }
4004
4004
  return this;
4005
4005
  }
4006
- _in2(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
4006
+ _in2(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
4007
4007
  const skip = emptyString(`${value ?? ''}`) && skipEmptyString;
4008
4008
  if (!skip) {
4009
4009
  if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
@@ -4018,16 +4018,16 @@ class StreamQuery {
4018
4018
  }
4019
4019
  }
4020
4020
  }
4021
- else if (breakExcuteIfSkip !== true) {
4021
+ else if (breakExcuteIfEmpty) {
4022
4022
  this.if_exec = false;
4023
4023
  }
4024
4024
  return this;
4025
4025
  }
4026
- _shift(key1, key2, value, op, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
4026
+ _shift(key1, key2, value, op, { not = '', paramName = '', breakExcuteIfEmpty = true } = {}) {
4027
4027
  if (value === null
4028
4028
  || value === undefined
4029
4029
  || emptyString(`${value ?? ''}`)) {
4030
- if (breakExcuteIfSkip) {
4030
+ if (breakExcuteIfEmpty) {
4031
4031
  this.if_exec = false;
4032
4032
  }
4033
4033
  return this;
@@ -4045,11 +4045,11 @@ class StreamQuery {
4045
4045
  }
4046
4046
  return this;
4047
4047
  }
4048
- _match(value, keys, { paramName = '', not = '', append = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
4048
+ _match(value, keys, { paramName = '', not = '', append = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
4049
4049
  if (value === null
4050
4050
  || value === undefined
4051
4051
  || emptyString(`${value ?? ''}`)) {
4052
- if (breakExcuteIfSkip) {
4052
+ if (breakExcuteIfEmpty) {
4053
4053
  this.if_exec = false;
4054
4054
  }
4055
4055
  return this;
@@ -4067,11 +4067,11 @@ class StreamQuery {
4067
4067
  }
4068
4068
  return this;
4069
4069
  }
4070
- _pow(key, value, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
4070
+ _pow(key, value, { not = '', paramName = '', breakExcuteIfEmpty = true } = {}) {
4071
4071
  if (value === null
4072
4072
  || value === undefined
4073
4073
  || emptyString(`${value ?? ''}`)) {
4074
- if (breakExcuteIfSkip) {
4074
+ if (breakExcuteIfEmpty) {
4075
4075
  this.if_exec = false;
4076
4076
  }
4077
4077
  return this;
@@ -4089,11 +4089,11 @@ class StreamQuery {
4089
4089
  }
4090
4090
  return this;
4091
4091
  }
4092
- _like(key, value, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
4092
+ _like(key, value, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
4093
4093
  if (value === null
4094
4094
  || value === undefined
4095
4095
  || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
4096
- if (breakExcuteIfSkip) {
4096
+ if (breakExcuteIfEmpty) {
4097
4097
  this.if_exec = false;
4098
4098
  }
4099
4099
  return this;
@@ -4111,11 +4111,11 @@ class StreamQuery {
4111
4111
  }
4112
4112
  return this;
4113
4113
  }
4114
- _includes(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = true } = {}) {
4114
+ _includes(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
4115
4115
  if (value === null
4116
4116
  || value === undefined
4117
4117
  || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
4118
- if (breakExcuteIfSkip) {
4118
+ if (breakExcuteIfEmpty) {
4119
4119
  this.if_exec = false;
4120
4120
  }
4121
4121
  return this;