test/func.test

   1 # 2001 September 15
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.  The
  12 # focus of this file is testing built-in functions.
  13 #
  14
  15 set testdir [file dirname $argv0]
  16 source $testdir/tester.tcl
  17 set testprefix func
  18
  19 # Create a table to work with.
  20 #
  21 do_test func-0.0 {
  22   execsql {CREATE TABLE tbl1(t1 text)}
  23   foreach word {this program is free software} {
  24     execsql "INSERT INTO tbl1 VALUES('$word')"
  25   }
  26   execsql {SELECT t1 FROM tbl1 ORDER BY t1}
  27 } {free is program software this}
  28 do_test func-0.1 {
  29   execsql {
  30      CREATE TABLE t2(a);
  31      INSERT INTO t2 VALUES(1);
  32      INSERT INTO t2 VALUES(NULL);
  33      INSERT INTO t2 VALUES(345);
  34      INSERT INTO t2 VALUES(NULL);
  35      INSERT INTO t2 VALUES(67890);
  36      SELECT * FROM t2;
  37   }
  38 } {1 {} 345 {} 67890}
  39
  40 # Check out the length() function
  41 #
  42 do_test func-1.0 {
  43   execsql {SELECT length(t1) FROM tbl1 ORDER BY t1}
  44 } {4 2 7 8 4}
  45 set isutf16 [regexp 16 [db one {PRAGMA encoding}]]
  46 do_execsql_test func-1.0b {
  47   SELECT octet_length(t1) FROM tbl1 ORDER BY t1;
  48 } [expr {$isutf16?"8 4 14 16 8":"4 2 7 8 4"}]
  49 do_test func-1.1 {
  50   set r [catch {execsql {SELECT length(*) FROM tbl1 ORDER BY t1}} msg]
  51   lappend r $msg
  52 } {1 {wrong number of arguments to function length()}}
  53 do_test func-1.2 {
  54   set r [catch {execsql {SELECT length(t1,5) FROM tbl1 ORDER BY t1}} msg]
  55   lappend r $msg
  56 } {1 {wrong number of arguments to function length()}}
  57 do_test func-1.3 {
  58   execsql {SELECT length(t1), count(*) FROM tbl1 GROUP BY length(t1)
  59            ORDER BY length(t1)}
  60 } {2 1 4 2 7 1 8 1}
  61 do_test func-1.4 {
  62   execsql {SELECT coalesce(length(a),-1) FROM t2}
  63 } {1 -1 3 -1 5}
  64 do_execsql_test func-1.5 {
  65   SELECT octet_length(12345);
  66 } [expr {(1+($isutf16!=0))*5}]
  67 db null NULL
  68 do_execsql_test func-1.6 {
  69   SELECT octet_length(NULL);
  70 } {NULL}
  71 do_execsql_test func-1.7 {
  72   SELECT octet_length(7.5);
  73 } [expr {(1+($isutf16!=0))*3}]
  74 do_execsql_test func-1.8 {
  75   SELECT octet_length(x'30313233');
  76 } {4}
  77 do_execsql_test func-1.9 {
  78   WITH c(x) AS (VALUES(char(350,351,352,353,354)))
  79   SELECT length(x), octet_length(x) FROM c;
  80 } {5 10}
  81
  82
  83
  84 # Check out the substr() function
  85 #
  86 db null {}
  87 do_test func-2.0 {
  88   execsql {SELECT substr(t1,1,2) FROM tbl1 ORDER BY t1}
  89 } {fr is pr so th}
  90 do_test func-2.1 {
  91   execsql {SELECT substr(t1,2,1) FROM tbl1 ORDER BY t1}
  92 } {r s r o h}
  93 do_test func-2.2 {
  94   execsql {SELECT substr(t1,3,3) FROM tbl1 ORDER BY t1}
  95 } {ee {} ogr ftw is}
  96 do_test func-2.3 {
  97   execsql {SELECT substr(t1,-1,1) FROM tbl1 ORDER BY t1}
  98 } {e s m e s}
  99 do_test func-2.4 {
 100   execsql {SELECT substr(t1,-1,2) FROM tbl1 ORDER BY t1}
 101 } {e s m e s}
 102 do_test func-2.5 {
 103   execsql {SELECT substr(t1,-2,1) FROM tbl1 ORDER BY t1}
 104 } {e i a r i}
 105 do_test func-2.6 {
 106   execsql {SELECT substr(t1,-2,2) FROM tbl1 ORDER BY t1}
 107 } {ee is am re is}
 108 do_test func-2.7 {
 109   execsql {SELECT substr(t1,-4,2) FROM tbl1 ORDER BY t1}
 110 } {fr {} gr wa th}
 111 do_test func-2.8 {
 112   execsql {SELECT t1 FROM tbl1 ORDER BY substr(t1,2,20)}
 113 } {this software free program is}
 114 do_test func-2.9 {
 115   execsql {SELECT substr(a,1,1) FROM t2}
 116 } {1 {} 3 {} 6}
 117 do_test func-2.10 {
 118   execsql {SELECT substr(a,2,2) FROM t2}
 119 } {{} {} 45 {} 78}
 120
 121 # Only do the following tests if TCL has UTF-8 capabilities
 122 #
 123 if {"\u1234"!="u1234"} {
 124
 125 # Put some UTF-8 characters in the database
 126 #
 127 do_test func-3.0 {
 128   execsql {DELETE FROM tbl1}
 129   foreach word "contains UTF-8 characters hi\u1234ho" {
 130     execsql "INSERT INTO tbl1 VALUES('$word')"
 131   }
 132   execsql {SELECT t1 FROM tbl1 ORDER BY t1}
 133 } "UTF-8 characters contains hi\u1234ho"
 134 do_test func-3.1 {
 135   execsql {SELECT length(t1) FROM tbl1 ORDER BY t1}
 136 } {5 10 8 5}
 137 do_test func-3.2 {
 138   execsql {SELECT substr(t1,1,2) FROM tbl1 ORDER BY t1}
 139 } {UT ch co hi}
 140 do_test func-3.3 {
 141   execsql {SELECT substr(t1,1,3) FROM tbl1 ORDER BY t1}
 142 } "UTF cha con hi\u1234"
 143 do_test func-3.4 {
 144   execsql {SELECT substr(t1,2,2) FROM tbl1 ORDER BY t1}
 145 } "TF ha on i\u1234"
 146 do_test func-3.5 {
 147   execsql {SELECT substr(t1,2,3) FROM tbl1 ORDER BY t1}
 148 } "TF- har ont i\u1234h"
 149 do_test func-3.6 {
 150   execsql {SELECT substr(t1,3,2) FROM tbl1 ORDER BY t1}
 151 } "F- ar nt \u1234h"
 152 do_test func-3.7 {
 153   execsql {SELECT substr(t1,4,2) FROM tbl1 ORDER BY t1}
 154 } "-8 ra ta ho"
 155 do_test func-3.8 {
 156   execsql {SELECT substr(t1,-1,1) FROM tbl1 ORDER BY t1}
 157 } "8 s s o"
 158 do_test func-3.9 {
 159   execsql {SELECT substr(t1,-3,2) FROM tbl1 ORDER BY t1}
 160 } "F- er in \u1234h"
 161 do_test func-3.10 {
 162   execsql {SELECT substr(t1,-4,3) FROM tbl1 ORDER BY t1}
 163 } "TF- ter ain i\u1234h"
 164 do_test func-3.99 {
 165   execsql {DELETE FROM tbl1}
 166   foreach word {this program is free software} {
 167     execsql "INSERT INTO tbl1 VALUES('$word')"
 168   }
 169   execsql {SELECT t1 FROM tbl1}
 170 } {this program is free software}
 171
 172 } ;# End \u1234!=u1234
 173
 174 # Test the abs() and round() functions.
 175 #
 176 ifcapable !floatingpoint {
 177   do_test func-4.1 {
 178     execsql {
 179       CREATE TABLE t1(a,b,c);
 180       INSERT INTO t1 VALUES(1,2,3);
 181       INSERT INTO t1 VALUES(2,12345678901234,-1234567890);
 182       INSERT INTO t1 VALUES(3,-2,-5);
 183     }
 184     catchsql {SELECT abs(a,b) FROM t1}
 185   } {1 {wrong number of arguments to function abs()}}
 186 }
 187 ifcapable floatingpoint {
 188   do_test func-4.1 {
 189     execsql {
 190       CREATE TABLE t1(a,b,c);
 191       INSERT INTO t1 VALUES(1,2,3);
 192       INSERT INTO t1 VALUES(2,1.2345678901234,-12345.67890);
 193       INSERT INTO t1 VALUES(3,-2,-5);
 194     }
 195     catchsql {SELECT abs(a,b) FROM t1}
 196   } {1 {wrong number of arguments to function abs()}}
 197 }
 198 do_test func-4.2 {
 199   catchsql {SELECT abs() FROM t1}
 200 } {1 {wrong number of arguments to function abs()}}
 201 ifcapable floatingpoint {
 202   do_test func-4.3 {
 203     catchsql {SELECT abs(b) FROM t1 ORDER BY a}
 204   } {0 {2 1.2345678901234 2}}
 205   do_test func-4.4 {
 206     catchsql {SELECT abs(c) FROM t1 ORDER BY a}
 207   } {0 {3 12345.6789 5}}
 208 }
 209 ifcapable !floatingpoint {
 210   if {[working_64bit_int]} {
 211     do_test func-4.3 {
 212       catchsql {SELECT abs(b) FROM t1 ORDER BY a}
 213     } {0 {2 12345678901234 2}}
 214   }
 215   do_test func-4.4 {
 216     catchsql {SELECT abs(c) FROM t1 ORDER BY a}
 217   } {0 {3 1234567890 5}}
 218 }
 219 do_test func-4.4.1 {
 220   execsql {SELECT abs(a) FROM t2}
 221 } {1 {} 345 {} 67890}
 222 do_test func-4.4.2 {
 223   execsql {SELECT abs(t1) FROM tbl1}
 224 } {0.0 0.0 0.0 0.0 0.0}
 225
 226 ifcapable floatingpoint {
 227   do_test func-4.5 {
 228     catchsql {SELECT round(a,b,c) FROM t1}
 229   } {1 {wrong number of arguments to function round()}}
 230   do_test func-4.6 {
 231     catchsql {SELECT round(b,2) FROM t1 ORDER BY b}
 232   } {0 {-2.0 1.23 2.0}}
 233   do_test func-4.7 {
 234     catchsql {SELECT round(b,0) FROM t1 ORDER BY a}
 235   } {0 {2.0 1.0 -2.0}}
 236   do_test func-4.8 {
 237     catchsql {SELECT round(c) FROM t1 ORDER BY a}
 238   } {0 {3.0 -12346.0 -5.0}}
 239   do_test func-4.9 {
 240     catchsql {SELECT round(c,a) FROM t1 ORDER BY a}
 241   } {0 {3.0 -12345.68 -5.0}}
 242   do_test func-4.10 {
 243     catchsql {SELECT 'x' || round(c,a) || 'y' FROM t1 ORDER BY a}
 244   } {0 {x3.0y x-12345.68y x-5.0y}}
 245   do_test func-4.11 {
 246     catchsql {SELECT round() FROM t1 ORDER BY a}
 247   } {1 {wrong number of arguments to function round()}}
 248   do_test func-4.12 {
 249     execsql {SELECT coalesce(round(a,2),'nil') FROM t2}
 250   } {1.0 nil 345.0 nil 67890.0}
 251   do_test func-4.13 {
 252     execsql {SELECT round(t1,2) FROM tbl1}
 253   } {0.0 0.0 0.0 0.0 0.0}
 254   do_test func-4.14 {
 255     execsql {SELECT typeof(round(5.1,1));}
 256   } {real}
 257   do_test func-4.15 {
 258     execsql {SELECT typeof(round(5.1));}
 259   } {real}
 260   do_test func-4.16 {
 261     catchsql {SELECT round(b,2.0) FROM t1 ORDER BY b}
 262   } {0 {-2.0 1.23 2.0}}
 263   # Verify some values reported on the mailing list.
 264   # Some of these fail on MSVC builds with 64-bit
 265   # long doubles, but not on GCC builds with 80-bit
 266   # long doubles.
 267   for {set i 1} {$i<999} {incr i} {
 268     set x1 [expr 40222.5 + $i]
 269     set x2 [expr 40223.0 + $i]
 270     do_test func-4.17.$i {
 271       execsql {SELECT round($x1);}
 272     } $x2
 273   }
 274   for {set i 1} {$i<999} {incr i} {
 275     set x1 [expr 40222.05 + $i]
 276     set x2 [expr 40222.10 + $i]
 277     do_test func-4.18.$i {
 278       execsql {SELECT round($x1,1);}
 279     } $x2
 280   }
 281   do_test func-4.20 {
 282     execsql {SELECT round(40223.4999999999);}
 283   } {40223.0}
 284   do_test func-4.21 {
 285     execsql {SELECT round(40224.4999999999);}
 286   } {40224.0}
 287   do_test func-4.22 {
 288     execsql {SELECT round(40225.4999999999);}
 289   } {40225.0}
 290   for {set i 1} {$i<10} {incr i} {
 291     do_test func-4.23.$i {
 292       execsql {SELECT round(40223.4999999999,$i);}
 293     } {40223.5}
 294     do_test func-4.24.$i {
 295       execsql {SELECT round(40224.4999999999,$i);}
 296     } {40224.5}
 297     do_test func-4.25.$i {
 298       execsql {SELECT round(40225.4999999999,$i);}
 299     } {40225.5}
 300   }
 301   for {set i 10} {$i<32} {incr i} {
 302     do_test func-4.26.$i {
 303       execsql {SELECT round(40223.4999999999,$i);}
 304     } {40223.4999999999}
 305     do_test func-4.27.$i {
 306       execsql {SELECT round(40224.4999999999,$i);}
 307     } {40224.4999999999}
 308     do_test func-4.28.$i {
 309       execsql {SELECT round(40225.4999999999,$i);}
 310     } {40225.4999999999}
 311   }
 312   do_test func-4.29 {
 313     execsql {SELECT round(1234567890.5);}
 314   } {1234567891.0}
 315   do_test func-4.30 {
 316     execsql {SELECT round(12345678901.5);}
 317   } {12345678902.0}
 318   do_test func-4.31 {
 319     execsql {SELECT round(123456789012.5);}
 320   } {123456789013.0}
 321   do_test func-4.32 {
 322     execsql {SELECT round(1234567890123.5);}
 323   } {1234567890124.0}
 324   do_test func-4.33 {
 325     execsql {SELECT round(12345678901234.5);}
 326   } {12345678901235.0}
 327   do_test func-4.34 {
 328     execsql {SELECT round(1234567890123.35,1);}
 329   } {1234567890123.4}
 330   do_test func-4.35 {
 331     execsql {SELECT round(1234567890123.445,2);}
 332   } {1234567890123.45}
 333   do_test func-4.36 {
 334     execsql {SELECT round(99999999999994.5);}
 335   } {99999999999995.0}
 336   do_test func-4.37 {
 337     execsql {SELECT round(9999999999999.55,1);}
 338   } {9999999999999.6}
 339   do_test func-4.38 {
 340     execsql {SELECT round(9999999999999.556,2);}
 341   } {9999999999999.56}
 342   do_test func-4.39 {
 343     string tolower [db eval {SELECT round(1e500), round(-1e500);}]
 344   } {inf -inf}
 345 }
 346
 347 # Test the upper() and lower() functions
 348 #
 349 do_test func-5.1 {
 350   execsql {SELECT upper(t1) FROM tbl1}
 351 } {THIS PROGRAM IS FREE SOFTWARE}
 352 do_test func-5.2 {
 353   execsql {SELECT lower(upper(t1)) FROM tbl1}
 354 } {this program is free software}
 355 do_test func-5.3 {
 356   execsql {SELECT upper(a), lower(a) FROM t2}
 357 } {1 1 {} {} 345 345 {} {} 67890 67890}
 358 ifcapable !icu {
 359   do_test func-5.4 {
 360     catchsql {SELECT upper(a,5) FROM t2}
 361   } {1 {wrong number of arguments to function upper()}}
 362 }
 363 do_test func-5.5 {
 364   catchsql {SELECT upper(*) FROM t2}
 365 } {1 {wrong number of arguments to function upper()}}
 366
 367 # Test the coalesce() and nullif() functions
 368 #
 369 do_test func-6.1 {
 370   execsql {SELECT coalesce(a,'xyz') FROM t2}
 371 } {1 xyz 345 xyz 67890}
 372 do_test func-6.2 {
 373   execsql {SELECT coalesce(upper(a),'nil') FROM t2}
 374 } {1 nil 345 nil 67890}
 375 do_test func-6.3 {
 376   execsql {SELECT coalesce(nullif(1,1),'nil')}
 377 } {nil}
 378 do_test func-6.4 {
 379   execsql {SELECT coalesce(nullif(1,2),'nil')}
 380 } {1}
 381 do_test func-6.5 {
 382   execsql {SELECT coalesce(nullif(1,NULL),'nil')}
 383 } {1}
 384
 385
 386 # Test the last_insert_rowid() function
 387 #
 388 do_test func-7.1 {
 389   execsql {SELECT last_insert_rowid()}
 390 } [db last_insert_rowid]
 391
 392 # Tests for aggregate functions and how they handle NULLs.
 393 #
 394 ifcapable floatingpoint {
 395   do_test func-8.1 {
 396     ifcapable explain {
 397       execsql {EXPLAIN SELECT sum(a) FROM t2;}
 398     }
 399     execsql {
 400       SELECT sum(a), count(a), round(avg(a),2), min(a), max(a), count(*) FROM t2;
 401     }
 402   } {68236 3 22745.33 1 67890 5}
 403 }
 404 ifcapable !floatingpoint {
 405   do_test func-8.1 {
 406     ifcapable explain {
 407       execsql {EXPLAIN SELECT sum(a) FROM t2;}
 408     }
 409     execsql {
 410       SELECT sum(a), count(a), avg(a), min(a), max(a), count(*) FROM t2;
 411     }
 412   } {68236 3 22745.0 1 67890 5}
 413 }
 414 do_test func-8.2 {
 415   execsql {
 416     SELECT max('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t2;
 417   }
 418 } {z+67890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP}
 419
 420 ifcapable tempdb {
 421   do_test func-8.3 {
 422     execsql {
 423       CREATE TEMP TABLE t3 AS SELECT a FROM t2 ORDER BY a DESC;
 424       SELECT min('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3;
 425     }
 426   } {z+1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP}
 427 } else {
 428   do_test func-8.3 {
 429     execsql {
 430       CREATE TABLE t3 AS SELECT a FROM t2 ORDER BY a DESC;
 431       SELECT min('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3;
 432     }
 433   } {z+1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP}
 434 }
 435 do_test func-8.4 {
 436   execsql {
 437     SELECT max('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3;
 438   }
 439 } {z+67890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP}
 440 ifcapable compound {
 441   do_test func-8.5 {
 442     execsql {
 443       SELECT sum(x) FROM (SELECT '9223372036' || '854775807' AS x
 444                           UNION ALL SELECT -9223372036854775807)
 445     }
 446   } {0}
 447   do_test func-8.6 {
 448     execsql {
 449       SELECT typeof(sum(x)) FROM (SELECT '9223372036' || '854775807' AS x
 450                           UNION ALL SELECT -9223372036854775807)
 451     }
 452   } {integer}
 453   do_test func-8.7 {
 454     execsql {
 455       SELECT typeof(sum(x)) FROM (SELECT '9223372036' || '854775808' AS x
 456                           UNION ALL SELECT -9223372036854775807)
 457     }
 458   } {real}
 459 ifcapable floatingpoint {
 460   do_test func-8.8 {
 461     execsql {
 462       SELECT sum(x)>0.0 FROM (SELECT '9223372036' || '854775808' AS x
 463                           UNION ALL SELECT -9223372036850000000)
 464     }
 465   } {1}
 466 }
 467 ifcapable !floatingpoint {
 468   do_test func-8.8 {
 469     execsql {
 470       SELECT sum(x)>0 FROM (SELECT '9223372036' || '854775808' AS x
 471                           UNION ALL SELECT -9223372036850000000)
 472     }
 473   } {1}
 474 }
 475 }
 476
 477 # How do you test the random() function in a meaningful, deterministic way?
 478 #
 479 do_test func-9.1 {
 480   execsql {
 481     SELECT random() is not null;
 482   }
 483 } {1}
 484 do_test func-9.2 {
 485   execsql {
 486     SELECT typeof(random());
 487   }
 488 } {integer}
 489 do_test func-9.3 {
 490   execsql {
 491     SELECT randomblob(32) is not null;
 492   }
 493 } {1}
 494 do_test func-9.4 {
 495   execsql {
 496     SELECT typeof(randomblob(32));
 497   }
 498 } {blob}
 499 do_test func-9.5 {
 500   execsql {
 501     SELECT length(randomblob(32)), length(randomblob(-5)),
 502            length(randomblob(2000))
 503   }
 504 } {32 1 2000}
 505
 506 # The "hex()" function was added in order to be able to render blobs
 507 # generated by randomblob().  So this seems like a good place to test
 508 # hex().
 509 #
 510 ifcapable bloblit {
 511   do_test func-9.10 {
 512     execsql {SELECT hex(x'00112233445566778899aAbBcCdDeEfF')}
 513   } {00112233445566778899AABBCCDDEEFF}
 514 }
 515 set encoding [db one {PRAGMA encoding}]
 516 if {$encoding=="UTF-16le"} {
 517   do_test func-9.11-utf16le {
 518     execsql {SELECT hex(replace('abcdefg','ef','12'))}
 519   } {6100620063006400310032006700}
 520   do_test func-9.12-utf16le {
 521     execsql {SELECT hex(replace('abcdefg','','12'))}
 522   } {6100620063006400650066006700}
 523   do_test func-9.13-utf16le {
 524     execsql {SELECT hex(replace('aabcdefg','a','aaa'))}
 525   } {610061006100610061006100620063006400650066006700}
 526 } elseif {$encoding=="UTF-8"} {
 527   do_test func-9.11-utf8 {
 528     execsql {SELECT hex(replace('abcdefg','ef','12'))}
 529   } {61626364313267}
 530   do_test func-9.12-utf8 {
 531     execsql {SELECT hex(replace('abcdefg','','12'))}
 532   } {61626364656667}
 533   do_test func-9.13-utf8 {
 534     execsql {SELECT hex(replace('aabcdefg','a','aaa'))}
 535   } {616161616161626364656667}
 536 }
 537 do_execsql_test func-9.14 {
 538   WITH RECURSIVE c(x) AS (
 539      VALUES(1)
 540      UNION ALL
 541      SELECT x+1 FROM c WHERE x<1040
 542   )
 543   SELECT
 544     count(*),
 545     sum(length(replace(printf('abc%.*cxyz',x,'m'),'m','nnnn'))-(6+x*4))
 546   FROM c;
 547 } {1040 0}
 548
 549 # Use the "sqlite_register_test_function" TCL command which is part of
 550 # the text fixture in order to verify correct operation of some of
 551 # the user-defined SQL function APIs that are not used by the built-in
 552 # functions.
 553 #
 554 set ::DB [sqlite3_connection_pointer db]
 555 sqlite_register_test_function $::DB testfunc
 556 do_test func-10.1 {
 557   catchsql {
 558     SELECT testfunc(NULL,NULL);
 559   }
 560 } {1 {first argument should be one of: int int64 string double null value}}
 561 do_test func-10.2 {
 562   execsql {
 563     SELECT testfunc(
 564      'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 565      'int', 1234
 566     );
 567   }
 568 } {1234}
 569 do_test func-10.3 {
 570   execsql {
 571     SELECT testfunc(
 572      'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 573      'string', NULL
 574     );
 575   }
 576 } {{}}
 577
 578 ifcapable floatingpoint {
 579   do_test func-10.4 {
 580     execsql {
 581       SELECT testfunc(
 582        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 583        'double', 1.234
 584       );
 585     }
 586   } {1.234}
 587   do_test func-10.5 {
 588     execsql {
 589       SELECT testfunc(
 590        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 591        'int', 1234,
 592        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 593        'string', NULL,
 594        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 595        'double', 1.234,
 596        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 597        'int', 1234,
 598        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 599        'string', NULL,
 600        'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 601        'double', 1.234
 602       );
 603     }
 604   } {1.234}
 605 }
 606
 607 # Test the built-in sqlite_version(*) SQL function.
 608 #
 609 do_test func-11.1 {
 610   execsql {
 611     SELECT sqlite_version(*);
 612   }
 613 } [sqlite3 -version]
 614
 615 # Test that destructors passed to sqlite3 by calls to sqlite3_result_text()
 616 # etc. are called. These tests use two special user-defined functions
 617 # (implemented in func.c) only available in test builds.
 618 #
 619 # Function test_destructor() takes one argument and returns a copy of the
 620 # text form of that argument. A destructor is associated with the return
 621 # value. Function test_destructor_count() returns the number of outstanding
 622 # destructor calls for values returned by test_destructor().
 623 #
 624 if {[db eval {PRAGMA encoding}]=="UTF-8"} {
 625   do_test func-12.1-utf8 {
 626     execsql {
 627       SELECT test_destructor('hello world'), test_destructor_count();
 628     }
 629   } {{hello world} 1}
 630 } else {
 631     ifcapable {utf16} {
 632       do_test func-12.1-utf16 {
 633         execsql {
 634           SELECT test_destructor16('hello world'), test_destructor_count();
 635         }
 636       } {{hello world} 1}
 637     }
 638 }
 639 do_test func-12.2 {
 640   execsql {
 641     SELECT test_destructor_count();
 642   }
 643 } {0}
 644 do_test func-12.3 {
 645   execsql {
 646     SELECT test_destructor('hello')||' world'
 647   }
 648 } {{hello world}}
 649 do_test func-12.4 {
 650   execsql {
 651     SELECT test_destructor_count();
 652   }
 653 } {0}
 654 do_test func-12.5 {
 655   execsql {
 656     CREATE TABLE t4(x);
 657     INSERT INTO t4 VALUES(test_destructor('hello'));
 658     INSERT INTO t4 VALUES(test_destructor('world'));
 659     SELECT min(test_destructor(x)), max(test_destructor(x)) FROM t4;
 660   }
 661 } {hello world}
 662 do_test func-12.6 {
 663   execsql {
 664     SELECT test_destructor_count();
 665   }
 666 } {0}
 667 do_test func-12.7 {
 668   execsql {
 669     DROP TABLE t4;
 670   }
 671 } {}
 672
 673
 674 # Test that the auxdata API for scalar functions works. This test uses
 675 # a special user-defined function only available in test builds,
 676 # test_auxdata(). Function test_auxdata() takes any number of arguments.
 677 do_test func-13.1 {
 678   execsql {
 679     SELECT test_auxdata('hello world');
 680   }
 681 } {0}
 682
 683 do_test func-13.2 {
 684   execsql {
 685     CREATE TABLE t4(a, b);
 686     INSERT INTO t4 VALUES('abc', 'def');
 687     INSERT INTO t4 VALUES('ghi', 'jkl');
 688   }
 689 } {}
 690 do_test func-13.3 {
 691   execsql {
 692     SELECT test_auxdata('hello world') FROM t4;
 693   }
 694 } {0 1}
 695 do_test func-13.4 {
 696   execsql {
 697     SELECT test_auxdata('hello world', 123) FROM t4;
 698   }
 699 } {{0 0} {1 1}}
 700 do_test func-13.5 {
 701   execsql {
 702     SELECT test_auxdata('hello world', a) FROM t4;
 703   }
 704 } {{0 0} {1 0}}
 705 do_test func-13.6 {
 706   execsql {
 707     SELECT test_auxdata('hello'||'world', a) FROM t4;
 708   }
 709 } {{0 0} {1 0}}
 710
 711 # Test that auxilary data is preserved between calls for SQL variables.
 712 do_test func-13.7 {
 713   set DB [sqlite3_connection_pointer db]
 714   set sql "SELECT test_auxdata( ? , a ) FROM t4;"
 715   set STMT [sqlite3_prepare $DB $sql -1 TAIL]
 716   sqlite3_bind_text $STMT 1 hello\000 -1
 717   set res [list]
 718   while { "SQLITE_ROW"==[sqlite3_step $STMT] } {
 719     lappend res [sqlite3_column_text $STMT 0]
 720   }
 721   lappend res [sqlite3_finalize $STMT]
 722 } {{0 0} {1 0} SQLITE_OK}
 723
 724 # Test that auxiliary data is discarded when a statement is reset.
 725 do_execsql_test 13.8.1 {
 726   SELECT test_auxdata('constant') FROM t4;
 727 } {0 1}
 728 do_execsql_test 13.8.2 {
 729   SELECT test_auxdata('constant') FROM t4;
 730 } {0 1}
 731 db cache flush
 732 do_execsql_test 13.8.3 {
 733   SELECT test_auxdata('constant') FROM t4;
 734 } {0 1}
 735 set V "one"
 736 do_execsql_test 13.8.4 {
 737   SELECT test_auxdata($V), $V FROM t4;
 738 } {0 one 1 one}
 739 set V "two"
 740 do_execsql_test 13.8.5 {
 741   SELECT test_auxdata($V), $V FROM t4;
 742 } {0 two 1 two}
 743 db cache flush
 744 set V "three"
 745 do_execsql_test 13.8.6 {
 746   SELECT test_auxdata($V), $V FROM t4;
 747 } {0 three 1 three}
 748
 749
 750 # Make sure that a function with a very long name is rejected
 751 do_test func-14.1 {
 752   catch {
 753     db function [string repeat X 254] {return "hello"}
 754   }
 755 } {0}
 756 do_test func-14.2 {
 757   catch {
 758     db function [string repeat X 256] {return "hello"}
 759   }
 760 } {1}
 761
 762 do_test func-15.1 {
 763   catchsql {select test_error(NULL)}
 764 } {1 {}}
 765 do_test func-15.2 {
 766   catchsql {select test_error('this is the error message')}
 767 } {1 {this is the error message}}
 768 do_test func-15.3 {
 769   catchsql {select test_error('this is the error message',12)}
 770 } {1 {this is the error message}}
 771 do_test func-15.4 {
 772   db errorcode
 773 } {12}
 774
 775 # Test the quote function for BLOB and NULL values.
 776 do_test func-16.1 {
 777   execsql {
 778     CREATE TABLE tbl2(a, b);
 779   }
 780   set STMT [sqlite3_prepare $::DB "INSERT INTO tbl2 VALUES(?, ?)" -1 TAIL]
 781   sqlite3_bind_blob $::STMT 1 abc 3
 782   sqlite3_step $::STMT
 783   sqlite3_finalize $::STMT
 784   execsql {
 785     SELECT quote(a), quote(b) FROM tbl2;
 786   }
 787 } {X'616263' NULL}
 788
 789 # Correctly handle function error messages that include %.  Ticket #1354
 790 #
 791 do_test func-17.1 {
 792   proc testfunc1 args {error "Error %d with %s percents %p"}
 793   db function testfunc1 ::testfunc1
 794   catchsql {
 795     SELECT testfunc1(1,2,3);
 796   }
 797 } {1 {Error %d with %s percents %p}}
 798
 799 # The SUM function should return integer results when all inputs are integer.
 800 #
 801 do_test func-18.1 {
 802   execsql {
 803     CREATE TABLE t5(x);
 804     INSERT INTO t5 VALUES(1);
 805     INSERT INTO t5 VALUES(-99);
 806     INSERT INTO t5 VALUES(10000);
 807     SELECT sum(x) FROM t5;
 808   }
 809 } {9902}
 810 ifcapable floatingpoint {
 811   do_test func-18.2 {
 812     execsql {
 813       INSERT INTO t5 VALUES(0.0);
 814       SELECT sum(x) FROM t5;
 815     }
 816   } {9902.0}
 817 }
 818
 819 # The sum of nothing is NULL.  But the sum of all NULLs is NULL.
 820 #
 821 # The TOTAL of nothing is 0.0.
 822 #
 823 do_test func-18.3 {
 824   execsql {
 825     DELETE FROM t5;
 826     SELECT sum(x), total(x) FROM t5;
 827   }
 828 } {{} 0.0}
 829 do_test func-18.4 {
 830   execsql {
 831     INSERT INTO t5 VALUES(NULL);
 832     SELECT sum(x), total(x) FROM t5
 833   }
 834 } {{} 0.0}
 835 do_test func-18.5 {
 836   execsql {
 837     INSERT INTO t5 VALUES(NULL);
 838     SELECT sum(x), total(x) FROM t5
 839   }
 840 } {{} 0.0}
 841 do_test func-18.6 {
 842   execsql {
 843     INSERT INTO t5 VALUES(123);
 844     SELECT sum(x), total(x) FROM t5
 845   }
 846 } {123 123.0}
 847
 848 # Ticket #1664, #1669, #1670, #1674: An integer overflow on SUM causes
 849 # an error. The non-standard TOTAL() function continues to give a helpful
 850 # result.
 851 #
 852 do_test func-18.10 {
 853   execsql {
 854     CREATE TABLE t6(x INTEGER);
 855     INSERT INTO t6 VALUES(1);
 856     INSERT INTO t6 VALUES(1<<62);
 857     SELECT sum(x) - ((1<<62)+1) from t6;
 858   }
 859 } 0
 860 do_test func-18.11 {
 861   execsql {
 862     SELECT typeof(sum(x)) FROM t6
 863   }
 864 } integer
 865 ifcapable floatingpoint {
 866   do_catchsql_test func-18.12 {
 867     INSERT INTO t6 VALUES(1<<62);
 868     SELECT sum(x) - ((1<<62)*2.0+1) from t6;
 869   } {1 {integer overflow}}
 870   do_catchsql_test func-18.13 {
 871     SELECT total(x) - ((1<<62)*2.0+1) FROM t6
 872   } {0 0.0}
 873 }
 874 if {[working_64bit_int]} {
 875   do_test func-18.14 {
 876     execsql {
 877       SELECT sum(-9223372036854775805);
 878     }
 879   } -9223372036854775805
 880 }
 881 ifcapable compound&&subquery {
 882
 883 do_test func-18.15 {
 884   catchsql {
 885     SELECT sum(x) FROM
 886        (SELECT 9223372036854775807 AS x UNION ALL
 887         SELECT 10 AS x);
 888   }
 889 } {1 {integer overflow}}
 890 if {[working_64bit_int]} {
 891   do_test func-18.16 {
 892     catchsql {
 893       SELECT sum(x) FROM
 894          (SELECT 9223372036854775807 AS x UNION ALL
 895           SELECT -10 AS x);
 896     }
 897   } {0 9223372036854775797}
 898   do_test func-18.17 {
 899     catchsql {
 900       SELECT sum(x) FROM
 901          (SELECT -9223372036854775807 AS x UNION ALL
 902           SELECT 10 AS x);
 903     }
 904   } {0 -9223372036854775797}
 905 }
 906 do_test func-18.18 {
 907   catchsql {
 908     SELECT sum(x) FROM
 909        (SELECT -9223372036854775807 AS x UNION ALL
 910         SELECT -10 AS x);
 911   }
 912 } {1 {integer overflow}}
 913 do_test func-18.19 {
 914   catchsql {
 915     SELECT sum(x) FROM (SELECT 9 AS x UNION ALL SELECT -10 AS x);
 916   }
 917 } {0 -1}
 918 do_test func-18.20 {
 919   catchsql {
 920     SELECT sum(x) FROM (SELECT -9 AS x UNION ALL SELECT 10 AS x);
 921   }
 922 } {0 1}
 923 do_test func-18.21 {
 924   catchsql {
 925     SELECT sum(x) FROM (SELECT -10 AS x UNION ALL SELECT 9 AS x);
 926   }
 927 } {0 -1}
 928 do_test func-18.22 {
 929   catchsql {
 930     SELECT sum(x) FROM (SELECT 10 AS x UNION ALL SELECT -9 AS x);
 931   }
 932 } {0 1}
 933
 934 } ;# ifcapable compound&&subquery
 935
 936 # Integer overflow on abs()
 937 #
 938 if {[working_64bit_int]} {
 939   do_test func-18.31 {
 940     catchsql {
 941       SELECT abs(-9223372036854775807);
 942     }
 943   } {0 9223372036854775807}
 944 }
 945 do_test func-18.32 {
 946   catchsql {
 947     SELECT abs(-9223372036854775807-1);
 948   }
 949 } {1 {integer overflow}}
 950
 951 # The MATCH function exists but is only a stub and always throws an error.
 952 #
 953 do_test func-19.1 {
 954   execsql {
 955     SELECT match(a,b) FROM t1 WHERE 0;
 956   }
 957 } {}
 958 do_test func-19.2 {
 959   catchsql {
 960     SELECT 'abc' MATCH 'xyz';
 961   }
 962 } {1 {unable to use function MATCH in the requested context}}
 963 do_test func-19.3 {
 964   catchsql {
 965     SELECT 'abc' NOT MATCH 'xyz';
 966   }
 967 } {1 {unable to use function MATCH in the requested context}}
 968 do_test func-19.4 {
 969   catchsql {
 970     SELECT match(1,2,3);
 971   }
 972 } {1 {wrong number of arguments to function match()}}
 973
 974 # Soundex tests.
 975 #
 976 if {![catch {db eval {SELECT soundex('hello')}}]} {
 977   set i 0
 978   foreach {name sdx} {
 979     euler        E460
 980     EULER        E460
 981     Euler        E460
 982     ellery       E460
 983     gauss        G200
 984     ghosh        G200
 985     hilbert      H416
 986     Heilbronn    H416
 987     knuth        K530
 988     kant         K530
 989     Lloyd        L300
 990     LADD         L300
 991     Lukasiewicz  L222
 992     Lissajous    L222
 993     A            A000
 994     12345        ?000
 995   } {
 996     incr i
 997     do_test func-20.$i {
 998       execsql {SELECT soundex($name)}
 999     } $sdx
1000   }
1001 }
1002
1003 # Tests of the REPLACE function.
1004 #
1005 do_test func-21.1 {
1006   catchsql {
1007     SELECT replace(1,2);
1008   }
1009 } {1 {wrong number of arguments to function replace()}}
1010 do_test func-21.2 {
1011   catchsql {
1012     SELECT replace(1,2,3,4);
1013   }
1014 } {1 {wrong number of arguments to function replace()}}
1015 do_test func-21.3 {
1016   execsql {
1017     SELECT typeof(replace('This is the main test string', NULL, 'ALT'));
1018   }
1019 } {null}
1020 do_test func-21.4 {
1021   execsql {
1022     SELECT typeof(replace(NULL, 'main', 'ALT'));
1023   }
1024 } {null}
1025 do_test func-21.5 {
1026   execsql {
1027     SELECT typeof(replace('This is the main test string', 'main', NULL));
1028   }
1029 } {null}
1030 do_test func-21.6 {
1031   execsql {
1032     SELECT replace('This is the main test string', 'main', 'ALT');
1033   }
1034 } {{This is the ALT test string}}
1035 do_test func-21.7 {
1036   execsql {
1037     SELECT replace('This is the main test string', 'main', 'larger-main');
1038   }
1039 } {{This is the larger-main test string}}
1040 do_test func-21.8 {
1041   execsql {
1042     SELECT replace('aaaaaaa', 'a', '0123456789');
1043   }
1044 } {0123456789012345678901234567890123456789012345678901234567890123456789}
1045
1046 ifcapable tclvar {
1047   do_test func-21.9 {
1048     # Attempt to exploit a buffer-overflow that at one time existed
1049     # in the REPLACE function.
1050     set ::str "[string repeat A 29998]CC[string repeat A 35537]"
1051     set ::rep [string repeat B 65536]
1052     execsql {
1053       SELECT LENGTH(REPLACE($::str, 'C', $::rep));
1054     }
1055   } [expr 29998 + 2*65536 + 35537]
1056 }
1057
1058 # Tests for the TRIM, LTRIM and RTRIM functions.
1059 #
1060 do_test func-22.1 {
1061   catchsql {SELECT trim(1,2,3)}
1062 } {1 {wrong number of arguments to function trim()}}
1063 do_test func-22.2 {
1064   catchsql {SELECT ltrim(1,2,3)}
1065 } {1 {wrong number of arguments to function ltrim()}}
1066 do_test func-22.3 {
1067   catchsql {SELECT rtrim(1,2,3)}
1068 } {1 {wrong number of arguments to function rtrim()}}
1069 do_test func-22.4 {
1070   execsql {SELECT trim('  hi  ');}
1071 } {hi}
1072 do_test func-22.5 {
1073   execsql {SELECT ltrim('  hi  ');}
1074 } {{hi  }}
1075 do_test func-22.6 {
1076   execsql {SELECT rtrim('  hi  ');}
1077 } {{  hi}}
1078 do_test func-22.7 {
1079   execsql {SELECT trim('  hi  ','xyz');}
1080 } {{  hi  }}
1081 do_test func-22.8 {
1082   execsql {SELECT ltrim('  hi  ','xyz');}
1083 } {{  hi  }}
1084 do_test func-22.9 {
1085   execsql {SELECT rtrim('  hi  ','xyz');}
1086 } {{  hi  }}
1087 do_test func-22.10 {
1088   execsql {SELECT trim('xyxzy  hi  zzzy','xyz');}
1089 } {{  hi  }}
1090 do_test func-22.11 {
1091   execsql {SELECT ltrim('xyxzy  hi  zzzy','xyz');}
1092 } {{  hi  zzzy}}
1093 do_test func-22.12 {
1094   execsql {SELECT rtrim('xyxzy  hi  zzzy','xyz');}
1095 } {{xyxzy  hi  }}
1096 do_test func-22.13 {
1097   execsql {SELECT trim('  hi  ','');}
1098 } {{  hi  }}
1099 if {[db one {PRAGMA encoding}]=="UTF-8"} {
1100   do_test func-22.14 {
1101     execsql {SELECT hex(trim(x'c280e1bfbff48fbfbf6869',x'6162e1bfbfc280'))}
1102   } {F48FBFBF6869}
1103   do_test func-22.15 {
1104     execsql {SELECT hex(trim(x'6869c280e1bfbff48fbfbf61',
1105                              x'6162e1bfbfc280f48fbfbf'))}
1106   } {6869}
1107   do_test func-22.16 {
1108     execsql {SELECT hex(trim(x'ceb1ceb2ceb3',x'ceb1'));}
1109   } {CEB2CEB3}
1110 }
1111 do_test func-22.20 {
1112   execsql {SELECT typeof(trim(NULL));}
1113 } {null}
1114 do_test func-22.21 {
1115   execsql {SELECT typeof(trim(NULL,'xyz'));}
1116 } {null}
1117 do_test func-22.22 {
1118   execsql {SELECT typeof(trim('hello',NULL));}
1119 } {null}
1120
1121 # 2021-06-15 - infinite loop due to unsigned character counter
1122 # overflow, reported by Zimuzo Ezeozue
1123 #
1124 do_execsql_test func-22.23 {
1125   SELECT trim('xyzzy',x'c0808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080');
1126 } {xyzzy}
1127
1128 # This is to test the deprecated sqlite3_aggregate_count() API.
1129 #
1130 ifcapable deprecated {
1131   do_test func-23.1 {
1132     sqlite3_create_aggregate db
1133     execsql {
1134       SELECT legacy_count() FROM t6;
1135     }
1136   } {3}
1137 }
1138
1139 # The group_concat() function.
1140 #
1141 do_test func-24.1 {
1142   execsql {
1143     SELECT group_concat(t1) FROM tbl1
1144   }
1145 } {this,program,is,free,software}
1146 do_test func-24.2 {
1147   execsql {
1148     SELECT group_concat(t1,' ') FROM tbl1
1149   }
1150 } {{this program is free software}}
1151 do_test func-24.3 {
1152   execsql {
1153     SELECT group_concat(t1,' ' || rowid || ' ') FROM tbl1
1154   }
1155 } {{this 2 program 3 is 4 free 5 software}}
1156 do_test func-24.4 {
1157   execsql {
1158     SELECT group_concat(NULL,t1) FROM tbl1
1159   }
1160 } {{}}
1161 do_test func-24.5 {
1162   execsql {
1163     SELECT group_concat(t1,NULL) FROM tbl1
1164   }
1165 } {thisprogramisfreesoftware}
1166 do_test func-24.6 {
1167   execsql {
1168     SELECT 'BEGIN-'||group_concat(t1) FROM tbl1
1169   }
1170 } {BEGIN-this,program,is,free,software}
1171
1172 # Ticket #3179:  Make sure aggregate functions can take many arguments.
1173 # None of the built-in aggregates do this, so use the md5sum() from the
1174 # test extensions.
1175 #
1176 unset -nocomplain midargs
1177 set midargs {}
1178 unset -nocomplain midres
1179 set midres {}
1180 unset -nocomplain result
1181 for {set i 1} {$i<[sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1]} {incr i} {
1182   append midargs ,'/$i'
1183   append midres /$i
1184   set result [md5 \
1185      "this${midres}program${midres}is${midres}free${midres}software${midres}"]
1186   set sql "SELECT md5sum(t1$midargs) FROM tbl1"
1187   do_test func-24.7.$i {
1188      db eval $::sql
1189   } $result
1190 }
1191
1192 # Ticket #3806.  If the initial string in a group_concat is an empty
1193 # string, the separator that follows should still be present.
1194 #
1195 do_test func-24.8 {
1196   execsql {
1197     SELECT group_concat(CASE t1 WHEN 'this' THEN '' ELSE t1 END) FROM tbl1
1198   }
1199 } {,program,is,free,software}
1200 do_test func-24.9 {
1201   execsql {
1202     SELECT group_concat(CASE WHEN t1!='software' THEN '' ELSE t1 END) FROM tbl1
1203   }
1204 } {,,,,software}
1205
1206 # Ticket #3923.  Initial empty strings have a separator.  But initial
1207 # NULLs do not.
1208 #
1209 do_test func-24.10 {
1210   execsql {
1211     SELECT group_concat(CASE t1 WHEN 'this' THEN null ELSE t1 END) FROM tbl1
1212   }
1213 } {program,is,free,software}
1214 do_test func-24.11 {
1215   execsql {
1216    SELECT group_concat(CASE WHEN t1!='software' THEN null ELSE t1 END) FROM tbl1
1217   }
1218 } {software}
1219 do_test func-24.12 {
1220   execsql {
1221     SELECT group_concat(CASE t1 WHEN 'this' THEN ''
1222                           WHEN 'program' THEN null ELSE t1 END) FROM tbl1
1223   }
1224 } {,is,free,software}
1225 # Tests to verify ticket http://www.sqlite.org/src/tktview/55746f9e65f8587c0
1226 do_test func-24.13 {
1227   execsql {
1228     SELECT typeof(group_concat(x)) FROM (SELECT '' AS x);
1229   }
1230 } {text}
1231 do_test func-24.14 {
1232   execsql {
1233     SELECT typeof(group_concat(x,''))
1234       FROM (SELECT '' AS x UNION ALL SELECT '');
1235   }
1236 } {text}
1237
1238
1239 # Use the test_isolation function to make sure that type conversions
1240 # on function arguments do not effect subsequent arguments.
1241 #
1242 do_test func-25.1 {
1243   execsql {SELECT test_isolation(t1,t1) FROM tbl1}
1244 } {this program is free software}
1245
1246 # Try to misuse the sqlite3_create_function() interface.  Verify that
1247 # errors are returned.
1248 #
1249 do_test func-26.1 {
1250   abuse_create_function db
1251 } {}
1252
1253 # The previous test (func-26.1) registered a function with a very long
1254 # function name that takes many arguments and always returns NULL.  Verify
1255 # that this function works correctly.
1256 #
1257 do_test func-26.2 {
1258   set a {}
1259   for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG} {incr i} {
1260     lappend a $i
1261   }
1262   db eval "
1263      SELECT nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789([join $a ,]);
1264   "
1265 } {{}}
1266 do_test func-26.3 {
1267   set a {}
1268   for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG+1} {incr i} {
1269     lappend a $i
1270   }
1271   catchsql "
1272      SELECT nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789([join $a ,]);
1273   "
1274 } {1 {too many arguments on function nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789}}
1275 do_test func-26.4 {
1276   set a {}
1277   for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG-1} {incr i} {
1278     lappend a $i
1279   }
1280   catchsql "
1281      SELECT nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789([join $a ,]);
1282   "
1283 } {1 {wrong number of arguments to function nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789()}}
1284 do_test func-26.5 {
1285   catchsql "
1286      SELECT nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678a(0);
1287   "
1288 } {1 {no such function: nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678a}}
1289 do_test func-26.6 {
1290   catchsql "
1291      SELECT nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789a(0);
1292   "
1293 } {1 {no such function: nullx_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789a}}
1294
1295 do_test func-27.1 {
1296   catchsql {SELECT coalesce()}
1297 } {1 {wrong number of arguments to function coalesce()}}
1298 do_test func-27.2 {
1299   catchsql {SELECT coalesce(1)}
1300 } {1 {wrong number of arguments to function coalesce()}}
1301 do_test func-27.3 {
1302   catchsql {SELECT coalesce(1,2)}
1303 } {0 1}
1304
1305 # Ticket 2d401a94287b5
1306 # Unknown function in a DEFAULT expression causes a segfault.
1307 #
1308 do_test func-28.1 {
1309   db eval {
1310     CREATE TABLE t28(x, y DEFAULT(nosuchfunc(1)));
1311   }
1312   catchsql {
1313     INSERT INTO t28(x) VALUES(1);
1314   }
1315 } {1 {unknown function: nosuchfunc()}}
1316
1317 # Verify that the length() and typeof() functions do not actually load
1318 # the content of their argument.
1319 #
1320 do_test func-29.1 {
1321   db eval {
1322     CREATE TABLE t29(id INTEGER PRIMARY KEY, x, y);
1323     INSERT INTO t29 VALUES(1, 2, 3), (2, NULL, 4), (3, 4.5, 5);
1324     INSERT INTO t29 VALUES(4, randomblob(1000000), 6);
1325     INSERT INTO t29 VALUES(5, 'hello', 7);
1326   }
1327   db close
1328   sqlite3 db test.db
1329   sqlite3_db_status db CACHE_MISS 1
1330   db eval {SELECT typeof(x), length(x), typeof(y) FROM t29 ORDER BY id}
1331 } {integer 1 integer null {} integer real 3 integer blob 1000000 integer text 5 integer}
1332 do_test func-29.2 {
1333   set x [lindex [sqlite3_db_status db CACHE_MISS 1] 1]
1334   if {$x<5} {set x 1}
1335   set x
1336 } {1}
1337 do_test func-29.3 {
1338   db close
1339   sqlite3 db test.db
1340   sqlite3_db_status db CACHE_MISS 1
1341   db eval {SELECT typeof(+x) FROM t29 ORDER BY id}
1342 } {integer null real blob text}
1343 if {[permutation] != "mmap"} {
1344   ifcapable !direct_read {
1345     do_test func-29.4 {
1346       set x [lindex [sqlite3_db_status db CACHE_MISS 1] 1]
1347       if {$x>100} {set x many}
1348       set x
1349     } {many}
1350   }
1351 }
1352 do_test func-29.5 {
1353   db close
1354   sqlite3 db test.db
1355   sqlite3_db_status db CACHE_MISS 1
1356   db eval {SELECT sum(length(x)) FROM t29}
1357 } {1000009}
1358 do_test func-29.6 {
1359   set x [lindex [sqlite3_db_status db CACHE_MISS 1] 1]
1360   if {$x<5} {set x 1}
1361   set x
1362 } {1}
1363
1364 # The OP_Column opcode has an optimization that avoids loading content
1365 # for fields with content-length=0 when the content offset is on an overflow
1366 # page.  Make sure the optimization works.
1367 #
1368 do_execsql_test func-29.10 {
1369   CREATE TABLE t29b(a,b,c,d,e,f,g,h,i);
1370   INSERT INTO t29b
1371    VALUES(1, hex(randomblob(2000)), null, 0, 1, '', zeroblob(0),'x',x'01');
1372   SELECT typeof(c), typeof(d), typeof(e), typeof(f),
1373          typeof(g), typeof(h), typeof(i) FROM t29b;
1374 } {null integer integer text blob text blob}
1375 do_execsql_test func-29.11 {
1376   SELECT length(f), length(g), length(h), length(i) FROM t29b;
1377 } {0 0 1 1}
1378 do_execsql_test func-29.12 {
1379   SELECT quote(f), quote(g), quote(h), quote(i) FROM t29b;
1380 } {'' X'' 'x' X'01'}
1381
1382 # EVIDENCE-OF: R-29701-50711 The unicode(X) function returns the numeric
1383 # unicode code point corresponding to the first character of the string
1384 # X.
1385 #
1386 # EVIDENCE-OF: R-55469-62130 The char(X1,X2,...,XN) function returns a
1387 # string composed of characters having the unicode code point values of
1388 # integers X1 through XN, respectively.
1389 #
1390 do_execsql_test func-30.1 {SELECT unicode('$');} 36
1391 do_execsql_test func-30.2 [subst {SELECT unicode('\u00A2');}] 162
1392 do_execsql_test func-30.3 [subst {SELECT unicode('\u20AC');}] 8364
1393 do_execsql_test func-30.4 {SELECT char(36,162,8364);} [subst {$\u00A2\u20AC}]
1394
1395 for {set i 1} {$i<0xd800} {incr i 13} {
1396   do_execsql_test func-30.5.$i {SELECT unicode(char($i))} $i
1397 }
1398 for {set i 57344} {$i<=0xfffd} {incr i 17} {
1399   if {$i==0xfeff} continue
1400   do_execsql_test func-30.5.$i {SELECT unicode(char($i))} $i
1401 }
1402 for {set i 65536} {$i<=0x10ffff} {incr i 139} {
1403   do_execsql_test func-30.5.$i {SELECT unicode(char($i))} $i
1404 }
1405
1406 # Test char().
1407 #
1408 do_execsql_test func-31.1 {
1409   SELECT char(), length(char()), typeof(char())
1410 } {{} 0 text}
1411
1412 # sqlite3_value_frombind()
1413 #
1414 do_execsql_test func-32.100 {
1415   SELECT test_frombind(1,2,3,4);
1416 } {0}
1417 do_execsql_test func-32.110 {
1418   SELECT test_frombind(1,2,?,4);
1419 } {4}
1420 do_execsql_test func-32.120 {
1421   SELECT test_frombind(1,(?),4,?+7);
1422 } {2}
1423 do_execsql_test func-32.130 {
1424   DROP TABLE IF EXISTS t1;
1425   CREATE TABLE t1(a,b,c,e,f);
1426   INSERT INTO t1 VALUES(1,2.5,'xyz',x'e0c1b2a3',null);
1427   SELECT test_frombind(a,b,c,e,f,$xyz) FROM t1;
1428 } {32}
1429 do_execsql_test func-32.140 {
1430   SELECT test_frombind(a,b,c,e,f,$xyz+f) FROM t1;
1431 } {0}
1432 do_execsql_test func-32.150 {
1433   SELECT test_frombind(x.a,y.b,x.c,:123,y.e,x.f,$xyz+y.f) FROM t1 x, t1 y;
1434 } {8}
1435
1436 # 2019-08-15
1437 # Direct-only functions.
1438 #
1439 proc testdirectonly {x} {return [expr {$x*2}]}
1440 do_test func-33.1 {
1441   db func testdirectonly -directonly testdirectonly
1442   db eval {SELECT testdirectonly(15)}
1443 } {30}
1444 do_catchsql_test func-33.2 {
1445   CREATE VIEW v33(y) AS SELECT testdirectonly(15);
1446   SELECT * FROM v33;
1447 } {1 {unsafe use of testdirectonly()}}
1448 do_execsql_test func-33.3 {
1449   SELECT * FROM (SELECT testdirectonly(15)) AS v33;
1450 } {30}
1451 do_execsql_test func-33.4 {
1452   WITH c(x) AS (SELECT testdirectonly(15))
1453   SELECT * FROM c;
1454 } {30}
1455 do_catchsql_test func-33.5 {
1456   WITH c(x) AS (SELECT * FROM v33)
1457   SELECT * FROM c;
1458 } {1 {unsafe use of testdirectonly()}}
1459 do_execsql_test func-33.10 {
1460   CREATE TABLE t33a(a,b);
1461   CREATE TABLE t33b(x,y);
1462   CREATE TRIGGER r1 AFTER INSERT ON t33a BEGIN
1463     INSERT INTO t33b(x,y) VALUES(testdirectonly(new.a),new.b);
1464   END;
1465 } {}
1466 do_catchsql_test func-33.11 {
1467   INSERT INTO t33a VALUES(1,2);
1468 } {1 {unsafe use of testdirectonly()}}
1469
1470 ifcapable altertable {
1471 do_execsql_test func-33.20 {
1472   ALTER TABLE t33a RENAME COLUMN a TO aaa;
1473   SELECT sql FROM sqlite_master WHERE name='r1';
1474 } {{CREATE TRIGGER r1 AFTER INSERT ON t33a BEGIN
1475     INSERT INTO t33b(x,y) VALUES(testdirectonly(new.aaa),new.b);
1476   END}}
1477 }
1478
1479 # 2020-01-09 Yongheng fuzzer find
1480 # The bug is in the register-validity debug logic, not in the SQLite core
1481 # and as such it only impacts debug builds.  Release builds work fine.
1482 #
1483 reset_db
1484 do_execsql_test func-34.10 {
1485   CREATE TABLE t1(a INT CHECK(
1486      datetime( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1487               10,11,12,13,14,15,16,17,18,19,
1488               20,21,22,23,24,25,26,27,28,29,
1489               30,31,32,33,34,35,36,37,38,39,
1490               40,41,42,43,44,45,46,47,48,a)
1491    )
1492   );
1493   INSERT INTO t1(a) VALUES(1),(2);
1494   SELECT * FROM t1;
1495 } {1 2}
1496
1497 # 2020-03-11 COALESCE() should short-circuit
1498 # See also ticket 3c9eadd2a6ba0aa5
1499 # Both issues stem from the fact that functions that could
1500 # throw exceptions were being factored out into initialization
1501 # code.  The fix was to put those function calls inside of
1502 # OP_Once instead.
1503 #
1504 reset_db
1505 do_execsql_test func-35.100 {
1506   CREATE TABLE t1(x);
1507   SELECT coalesce(x, abs(-9223372036854775808)) FROM t1;
1508 } {}
1509 do_execsql_test func-35.110 {
1510   SELECT coalesce(x, 'xyz' LIKE printf('%.1000000c','y')) FROM t1;
1511 } {}
1512 do_execsql_test func-35.200 {
1513   CREATE TABLE t0(c0 CHECK(ABS(-9223372036854775808)));
1514   PRAGMA integrity_check;
1515 } {ok}
1516
1517 # 2021-01-07:  The -> and ->> operators.
1518 #
1519 proc ptr1 {a b} { return "$a->$b" }
1520 db func -> ptr1
1521 proc ptr2 {a b} { return "$a->>$b" }
1522 db func ->> ptr2
1523 do_execsql_test func-36.100 {
1524   SELECT 123 -> 456
1525 } {123->456}
1526 do_execsql_test func-36.110 {
1527   SELECT 123 ->> 456
1528 } {123->>456}
1529
1530 # 2023-06-26
1531 # Enhanced precision of SUM().
1532 #
1533 reset_db
1534 do_catchsql_test func-37.100 {
1535   WITH c(x) AS (VALUES(9223372036854775807),(9223372036854775807),
1536                       (123),(-9223372036854775807),(-9223372036854775807))
1537   SELECT sum(x) FROM c;
1538 } {1 {integer overflow}}
1539 do_catchsql_test func-37.110 {
1540   WITH c(x) AS (VALUES(9223372036854775807),(1))
1541   SELECT sum(x) FROM c;
1542 } {1 {integer overflow}}
1543 do_catchsql_test func-37.120 {
1544   WITH c(x) AS (VALUES(9223372036854775807),(10000),(-10010))
1545   SELECT sum(x) FROM c;
1546 } {1 {integer overflow}}
1547
1548 # 2023-08-28 forum post https://sqlite.org/forum/forumpost/1c06ddcacc86032a
1549 # Incorrect handling of infinity by SUM().
1550 #
1551 do_execsql_test func-38.100 {
1552   WITH t1(x) AS (VALUES(9e+999)) SELECT sum(x), avg(x), total(x) FROM t1;
1553   WITH t1(x) AS (VALUES(-9e+999)) SELECT sum(x), avg(x), total(x) FROM t1;
1554 } {Inf Inf Inf -Inf -Inf -Inf}
1555
1556 finish_test