/trunk/test/func.test |
@@ -0,0 +1,1250 @@ |
# 2001 September 15 |
# |
# The author disclaims copyright to this source code. In place of |
# a legal notice, here is a blessing: |
# |
# May you do good and not evil. |
# May you find forgiveness for yourself and forgive others. |
# May you share freely, never taking more than you give. |
# |
#*********************************************************************** |
# This file implements regression tests for SQLite library. The |
# focus of this file is testing built-in functions. |
# |
|
set testdir [file dirname $argv0] |
source $testdir/tester.tcl |
|
# Create a table to work with. |
# |
do_test func-0.0 { |
execsql {CREATE TABLE tbl1(t1 text)} |
foreach word {this program is free software} { |
execsql "INSERT INTO tbl1 VALUES('$word')" |
} |
execsql {SELECT t1 FROM tbl1 ORDER BY t1} |
} {free is program software this} |
do_test func-0.1 { |
execsql { |
CREATE TABLE t2(a); |
INSERT INTO t2 VALUES(1); |
INSERT INTO t2 VALUES(NULL); |
INSERT INTO t2 VALUES(345); |
INSERT INTO t2 VALUES(NULL); |
INSERT INTO t2 VALUES(67890); |
SELECT * FROM t2; |
} |
} {1 {} 345 {} 67890} |
|
# Check out the length() function |
# |
do_test func-1.0 { |
execsql {SELECT length(t1) FROM tbl1 ORDER BY t1} |
} {4 2 7 8 4} |
do_test func-1.1 { |
set r [catch {execsql {SELECT length(*) FROM tbl1 ORDER BY t1}} msg] |
lappend r $msg |
} {1 {wrong number of arguments to function length()}} |
do_test func-1.2 { |
set r [catch {execsql {SELECT length(t1,5) FROM tbl1 ORDER BY t1}} msg] |
lappend r $msg |
} {1 {wrong number of arguments to function length()}} |
do_test func-1.3 { |
execsql {SELECT length(t1), count(*) FROM tbl1 GROUP BY length(t1) |
ORDER BY length(t1)} |
} {2 1 4 2 7 1 8 1} |
do_test func-1.4 { |
execsql {SELECT coalesce(length(a),-1) FROM t2} |
} {1 -1 3 -1 5} |
|
# Check out the substr() function |
# |
do_test func-2.0 { |
execsql {SELECT substr(t1,1,2) FROM tbl1 ORDER BY t1} |
} {fr is pr so th} |
do_test func-2.1 { |
execsql {SELECT substr(t1,2,1) FROM tbl1 ORDER BY t1} |
} {r s r o h} |
do_test func-2.2 { |
execsql {SELECT substr(t1,3,3) FROM tbl1 ORDER BY t1} |
} {ee {} ogr ftw is} |
do_test func-2.3 { |
execsql {SELECT substr(t1,-1,1) FROM tbl1 ORDER BY t1} |
} {e s m e s} |
do_test func-2.4 { |
execsql {SELECT substr(t1,-1,2) FROM tbl1 ORDER BY t1} |
} {e s m e s} |
do_test func-2.5 { |
execsql {SELECT substr(t1,-2,1) FROM tbl1 ORDER BY t1} |
} {e i a r i} |
do_test func-2.6 { |
execsql {SELECT substr(t1,-2,2) FROM tbl1 ORDER BY t1} |
} {ee is am re is} |
do_test func-2.7 { |
execsql {SELECT substr(t1,-4,2) FROM tbl1 ORDER BY t1} |
} {fr {} gr wa th} |
do_test func-2.8 { |
execsql {SELECT t1 FROM tbl1 ORDER BY substr(t1,2,20)} |
} {this software free program is} |
do_test func-2.9 { |
execsql {SELECT substr(a,1,1) FROM t2} |
} {1 {} 3 {} 6} |
do_test func-2.10 { |
execsql {SELECT substr(a,2,2) FROM t2} |
} {{} {} 45 {} 78} |
|
# Only do the following tests if TCL has UTF-8 capabilities |
# |
if {"\u1234"!="u1234"} { |
|
# Put some UTF-8 characters in the database |
# |
do_test func-3.0 { |
execsql {DELETE FROM tbl1} |
foreach word "contains UTF-8 characters hi\u1234ho" { |
execsql "INSERT INTO tbl1 VALUES('$word')" |
} |
execsql {SELECT t1 FROM tbl1 ORDER BY t1} |
} "UTF-8 characters contains hi\u1234ho" |
do_test func-3.1 { |
execsql {SELECT length(t1) FROM tbl1 ORDER BY t1} |
} {5 10 8 5} |
do_test func-3.2 { |
execsql {SELECT substr(t1,1,2) FROM tbl1 ORDER BY t1} |
} {UT ch co hi} |
do_test func-3.3 { |
execsql {SELECT substr(t1,1,3) FROM tbl1 ORDER BY t1} |
} "UTF cha con hi\u1234" |
do_test func-3.4 { |
execsql {SELECT substr(t1,2,2) FROM tbl1 ORDER BY t1} |
} "TF ha on i\u1234" |
do_test func-3.5 { |
execsql {SELECT substr(t1,2,3) FROM tbl1 ORDER BY t1} |
} "TF- har ont i\u1234h" |
do_test func-3.6 { |
execsql {SELECT substr(t1,3,2) FROM tbl1 ORDER BY t1} |
} "F- ar nt \u1234h" |
do_test func-3.7 { |
execsql {SELECT substr(t1,4,2) FROM tbl1 ORDER BY t1} |
} "-8 ra ta ho" |
do_test func-3.8 { |
execsql {SELECT substr(t1,-1,1) FROM tbl1 ORDER BY t1} |
} "8 s s o" |
do_test func-3.9 { |
execsql {SELECT substr(t1,-3,2) FROM tbl1 ORDER BY t1} |
} "F- er in \u1234h" |
do_test func-3.10 { |
execsql {SELECT substr(t1,-4,3) FROM tbl1 ORDER BY t1} |
} "TF- ter ain i\u1234h" |
do_test func-3.99 { |
execsql {DELETE FROM tbl1} |
foreach word {this program is free software} { |
execsql "INSERT INTO tbl1 VALUES('$word')" |
} |
execsql {SELECT t1 FROM tbl1} |
} {this program is free software} |
|
} ;# End \u1234!=u1234 |
|
# Test the abs() and round() functions. |
# |
ifcapable !floatingpoint { |
do_test func-4.1 { |
execsql { |
CREATE TABLE t1(a,b,c); |
INSERT INTO t1 VALUES(1,2,3); |
INSERT INTO t1 VALUES(2,12345678901234,-1234567890); |
INSERT INTO t1 VALUES(3,-2,-5); |
} |
catchsql {SELECT abs(a,b) FROM t1} |
} {1 {wrong number of arguments to function abs()}} |
} |
ifcapable floatingpoint { |
do_test func-4.1 { |
execsql { |
CREATE TABLE t1(a,b,c); |
INSERT INTO t1 VALUES(1,2,3); |
INSERT INTO t1 VALUES(2,1.2345678901234,-12345.67890); |
INSERT INTO t1 VALUES(3,-2,-5); |
} |
catchsql {SELECT abs(a,b) FROM t1} |
} {1 {wrong number of arguments to function abs()}} |
} |
do_test func-4.2 { |
catchsql {SELECT abs() FROM t1} |
} {1 {wrong number of arguments to function abs()}} |
ifcapable floatingpoint { |
do_test func-4.3 { |
catchsql {SELECT abs(b) FROM t1 ORDER BY a} |
} {0 {2 1.2345678901234 2}} |
do_test func-4.4 { |
catchsql {SELECT abs(c) FROM t1 ORDER BY a} |
} {0 {3 12345.6789 5}} |
} |
ifcapable !floatingpoint { |
if {[working_64bit_int]} { |
do_test func-4.3 { |
catchsql {SELECT abs(b) FROM t1 ORDER BY a} |
} {0 {2 12345678901234 2}} |
} |
do_test func-4.4 { |
catchsql {SELECT abs(c) FROM t1 ORDER BY a} |
} {0 {3 1234567890 5}} |
} |
do_test func-4.4.1 { |
execsql {SELECT abs(a) FROM t2} |
} {1 {} 345 {} 67890} |
do_test func-4.4.2 { |
execsql {SELECT abs(t1) FROM tbl1} |
} {0.0 0.0 0.0 0.0 0.0} |
|
ifcapable floatingpoint { |
do_test func-4.5 { |
catchsql {SELECT round(a,b,c) FROM t1} |
} {1 {wrong number of arguments to function round()}} |
do_test func-4.6 { |
catchsql {SELECT round(b,2) FROM t1 ORDER BY b} |
} {0 {-2.0 1.23 2.0}} |
do_test func-4.7 { |
catchsql {SELECT round(b,0) FROM t1 ORDER BY a} |
} {0 {2.0 1.0 -2.0}} |
do_test func-4.8 { |
catchsql {SELECT round(c) FROM t1 ORDER BY a} |
} {0 {3.0 -12346.0 -5.0}} |
do_test func-4.9 { |
catchsql {SELECT round(c,a) FROM t1 ORDER BY a} |
} {0 {3.0 -12345.68 -5.0}} |
do_test func-4.10 { |
catchsql {SELECT 'x' || round(c,a) || 'y' FROM t1 ORDER BY a} |
} {0 {x3.0y x-12345.68y x-5.0y}} |
do_test func-4.11 { |
catchsql {SELECT round() FROM t1 ORDER BY a} |
} {1 {wrong number of arguments to function round()}} |
do_test func-4.12 { |
execsql {SELECT coalesce(round(a,2),'nil') FROM t2} |
} {1.0 nil 345.0 nil 67890.0} |
do_test func-4.13 { |
execsql {SELECT round(t1,2) FROM tbl1} |
} {0.0 0.0 0.0 0.0 0.0} |
do_test func-4.14 { |
execsql {SELECT typeof(round(5.1,1));} |
} {real} |
do_test func-4.15 { |
execsql {SELECT typeof(round(5.1));} |
} {real} |
do_test func-4.16 { |
catchsql {SELECT round(b,2.0) FROM t1 ORDER BY b} |
} {0 {-2.0 1.23 2.0}} |
# Verify some values reported on the mailing list. |
# Some of these fail on MSVC builds with 64-bit |
# long doubles, but not on GCC builds with 80-bit |
# long doubles. |
for {set i 1} {$i<999} {incr i} { |
set x1 [expr 40222.5 + $i] |
set x2 [expr 40223.0 + $i] |
do_test func-4.17.$i { |
execsql {SELECT round($x1);} |
} $x2 |
} |
for {set i 1} {$i<999} {incr i} { |
set x1 [expr 40222.05 + $i] |
set x2 [expr 40222.10 + $i] |
do_test func-4.18.$i { |
execsql {SELECT round($x1,1);} |
} $x2 |
} |
do_test func-4.20 { |
execsql {SELECT round(40223.4999999999);} |
} {40223.0} |
do_test func-4.21 { |
execsql {SELECT round(40224.4999999999);} |
} {40224.0} |
do_test func-4.22 { |
execsql {SELECT round(40225.4999999999);} |
} {40225.0} |
for {set i 1} {$i<10} {incr i} { |
do_test func-4.23.$i { |
execsql {SELECT round(40223.4999999999,$i);} |
} {40223.5} |
do_test func-4.24.$i { |
execsql {SELECT round(40224.4999999999,$i);} |
} {40224.5} |
do_test func-4.25.$i { |
execsql {SELECT round(40225.4999999999,$i);} |
} {40225.5} |
} |
for {set i 10} {$i<32} {incr i} { |
do_test func-4.26.$i { |
execsql {SELECT round(40223.4999999999,$i);} |
} {40223.4999999999} |
do_test func-4.27.$i { |
execsql {SELECT round(40224.4999999999,$i);} |
} {40224.4999999999} |
do_test func-4.28.$i { |
execsql {SELECT round(40225.4999999999,$i);} |
} {40225.4999999999} |
} |
do_test func-4.29 { |
execsql {SELECT round(1234567890.5);} |
} {1234567891.0} |
do_test func-4.30 { |
execsql {SELECT round(12345678901.5);} |
} {12345678902.0} |
do_test func-4.31 { |
execsql {SELECT round(123456789012.5);} |
} {123456789013.0} |
do_test func-4.32 { |
execsql {SELECT round(1234567890123.5);} |
} {1234567890124.0} |
do_test func-4.33 { |
execsql {SELECT round(12345678901234.5);} |
} {12345678901235.0} |
do_test func-4.34 { |
execsql {SELECT round(1234567890123.35,1);} |
} {1234567890123.4} |
do_test func-4.35 { |
execsql {SELECT round(1234567890123.445,2);} |
} {1234567890123.45} |
do_test func-4.36 { |
execsql {SELECT round(99999999999994.5);} |
} {99999999999995.0} |
do_test func-4.37 { |
execsql {SELECT round(9999999999999.55,1);} |
} {9999999999999.6} |
do_test func-4.38 { |
execsql {SELECT round(9999999999999.555,2);} |
} {9999999999999.56} |
} |
|
# Test the upper() and lower() functions |
# |
do_test func-5.1 { |
execsql {SELECT upper(t1) FROM tbl1} |
} {THIS PROGRAM IS FREE SOFTWARE} |
do_test func-5.2 { |
execsql {SELECT lower(upper(t1)) FROM tbl1} |
} {this program is free software} |
do_test func-5.3 { |
execsql {SELECT upper(a), lower(a) FROM t2} |
} {1 1 {} {} 345 345 {} {} 67890 67890} |
ifcapable !icu { |
do_test func-5.4 { |
catchsql {SELECT upper(a,5) FROM t2} |
} {1 {wrong number of arguments to function upper()}} |
} |
do_test func-5.5 { |
catchsql {SELECT upper(*) FROM t2} |
} {1 {wrong number of arguments to function upper()}} |
|
# Test the coalesce() and nullif() functions |
# |
do_test func-6.1 { |
execsql {SELECT coalesce(a,'xyz') FROM t2} |
} {1 xyz 345 xyz 67890} |
do_test func-6.2 { |
execsql {SELECT coalesce(upper(a),'nil') FROM t2} |
} {1 nil 345 nil 67890} |
do_test func-6.3 { |
execsql {SELECT coalesce(nullif(1,1),'nil')} |
} {nil} |
do_test func-6.4 { |
execsql {SELECT coalesce(nullif(1,2),'nil')} |
} {1} |
do_test func-6.5 { |
execsql {SELECT coalesce(nullif(1,NULL),'nil')} |
} {1} |
|
|
# Test the last_insert_rowid() function |
# |
do_test func-7.1 { |
execsql {SELECT last_insert_rowid()} |
} [db last_insert_rowid] |
|
# Tests for aggregate functions and how they handle NULLs. |
# |
ifcapable floatingpoint { |
do_test func-8.1 { |
ifcapable explain { |
execsql {EXPLAIN SELECT sum(a) FROM t2;} |
} |
execsql { |
SELECT sum(a), count(a), round(avg(a),2), min(a), max(a), count(*) FROM t2; |
} |
} {68236 3 22745.33 1 67890 5} |
} |
ifcapable !floatingpoint { |
do_test func-8.1 { |
ifcapable explain { |
execsql {EXPLAIN SELECT sum(a) FROM t2;} |
} |
execsql { |
SELECT sum(a), count(a), avg(a), min(a), max(a), count(*) FROM t2; |
} |
} {68236 3 22745.0 1 67890 5} |
} |
do_test func-8.2 { |
execsql { |
SELECT max('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t2; |
} |
} {z+67890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP} |
|
ifcapable tempdb { |
do_test func-8.3 { |
execsql { |
CREATE TEMP TABLE t3 AS SELECT a FROM t2 ORDER BY a DESC; |
SELECT min('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3; |
} |
} {z+1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP} |
} else { |
do_test func-8.3 { |
execsql { |
CREATE TABLE t3 AS SELECT a FROM t2 ORDER BY a DESC; |
SELECT min('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3; |
} |
} {z+1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP} |
} |
do_test func-8.4 { |
execsql { |
SELECT max('z+'||a||'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP') FROM t3; |
} |
} {z+67890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP} |
ifcapable compound { |
do_test func-8.5 { |
execsql { |
SELECT sum(x) FROM (SELECT '9223372036' || '854775807' AS x |
UNION ALL SELECT -9223372036854775807) |
} |
} {0} |
do_test func-8.6 { |
execsql { |
SELECT typeof(sum(x)) FROM (SELECT '9223372036' || '854775807' AS x |
UNION ALL SELECT -9223372036854775807) |
} |
} {integer} |
do_test func-8.7 { |
execsql { |
SELECT typeof(sum(x)) FROM (SELECT '9223372036' || '854775808' AS x |
UNION ALL SELECT -9223372036854775807) |
} |
} {real} |
ifcapable floatingpoint { |
do_test func-8.8 { |
execsql { |
SELECT sum(x)>0.0 FROM (SELECT '9223372036' || '854775808' AS x |
UNION ALL SELECT -9223372036850000000) |
} |
} {1} |
} |
ifcapable !floatingpoint { |
do_test func-8.8 { |
execsql { |
SELECT sum(x)>0 FROM (SELECT '9223372036' || '854775808' AS x |
UNION ALL SELECT -9223372036850000000) |
} |
} {1} |
} |
} |
|
# How do you test the random() function in a meaningful, deterministic way? |
# |
do_test func-9.1 { |
execsql { |
SELECT random() is not null; |
} |
} {1} |
do_test func-9.2 { |
execsql { |
SELECT typeof(random()); |
} |
} {integer} |
do_test func-9.3 { |
execsql { |
SELECT randomblob(32) is not null; |
} |
} {1} |
do_test func-9.4 { |
execsql { |
SELECT typeof(randomblob(32)); |
} |
} {blob} |
do_test func-9.5 { |
execsql { |
SELECT length(randomblob(32)), length(randomblob(-5)), |
length(randomblob(2000)) |
} |
} {32 1 2000} |
|
# The "hex()" function was added in order to be able to render blobs |
# generated by randomblob(). So this seems like a good place to test |
# hex(). |
# |
ifcapable bloblit { |
do_test func-9.10 { |
execsql {SELECT hex(x'00112233445566778899aAbBcCdDeEfF')} |
} {00112233445566778899AABBCCDDEEFF} |
} |
set encoding [db one {PRAGMA encoding}] |
if {$encoding=="UTF-16le"} { |
do_test func-9.11-utf16le { |
execsql {SELECT hex(replace('abcdefg','ef','12'))} |
} {6100620063006400310032006700} |
do_test func-9.12-utf16le { |
execsql {SELECT hex(replace('abcdefg','','12'))} |
} {6100620063006400650066006700} |
do_test func-9.13-utf16le { |
execsql {SELECT hex(replace('aabcdefg','a','aaa'))} |
} {610061006100610061006100620063006400650066006700} |
} elseif {$encoding=="UTF-8"} { |
do_test func-9.11-utf8 { |
execsql {SELECT hex(replace('abcdefg','ef','12'))} |
} {61626364313267} |
do_test func-9.12-utf8 { |
execsql {SELECT hex(replace('abcdefg','','12'))} |
} {61626364656667} |
do_test func-9.13-utf8 { |
execsql {SELECT hex(replace('aabcdefg','a','aaa'))} |
} {616161616161626364656667} |
} |
|
# Use the "sqlite_register_test_function" TCL command which is part of |
# the text fixture in order to verify correct operation of some of |
# the user-defined SQL function APIs that are not used by the built-in |
# functions. |
# |
set ::DB [sqlite3_connection_pointer db] |
sqlite_register_test_function $::DB testfunc |
do_test func-10.1 { |
catchsql { |
SELECT testfunc(NULL,NULL); |
} |
} {1 {first argument should be one of: int int64 string double null value}} |
do_test func-10.2 { |
execsql { |
SELECT testfunc( |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'int', 1234 |
); |
} |
} {1234} |
do_test func-10.3 { |
execsql { |
SELECT testfunc( |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'string', NULL |
); |
} |
} {{}} |
|
ifcapable floatingpoint { |
do_test func-10.4 { |
execsql { |
SELECT testfunc( |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'double', 1.234 |
); |
} |
} {1.234} |
do_test func-10.5 { |
execsql { |
SELECT testfunc( |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'int', 1234, |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'string', NULL, |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'double', 1.234, |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'int', 1234, |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'string', NULL, |
'string', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', |
'double', 1.234 |
); |
} |
} {1.234} |
} |
|
# Test the built-in sqlite_version(*) SQL function. |
# |
do_test func-11.1 { |
execsql { |
SELECT sqlite_version(*); |
} |
} [sqlite3 -version] |
|
# Test that destructors passed to sqlite3 by calls to sqlite3_result_text() |
# etc. are called. These tests use two special user-defined functions |
# (implemented in func.c) only available in test builds. |
# |
# Function test_destructor() takes one argument and returns a copy of the |
# text form of that argument. A destructor is associated with the return |
# value. Function test_destructor_count() returns the number of outstanding |
# destructor calls for values returned by test_destructor(). |
# |
if {[db eval {PRAGMA encoding}]=="UTF-8"} { |
do_test func-12.1-utf8 { |
execsql { |
SELECT test_destructor('hello world'), test_destructor_count(); |
} |
} {{hello world} 1} |
} else { |
ifcapable {utf16} { |
do_test func-12.1-utf16 { |
execsql { |
SELECT test_destructor16('hello world'), test_destructor_count(); |
} |
} {{hello world} 1} |
} |
} |
do_test func-12.2 { |
execsql { |
SELECT test_destructor_count(); |
} |
} {0} |
do_test func-12.3 { |
execsql { |
SELECT test_destructor('hello')||' world' |
} |
} {{hello world}} |
do_test func-12.4 { |
execsql { |
SELECT test_destructor_count(); |
} |
} {0} |
do_test func-12.5 { |
execsql { |
CREATE TABLE t4(x); |
INSERT INTO t4 VALUES(test_destructor('hello')); |
INSERT INTO t4 VALUES(test_destructor('world')); |
SELECT min(test_destructor(x)), max(test_destructor(x)) FROM t4; |
} |
} {hello world} |
do_test func-12.6 { |
execsql { |
SELECT test_destructor_count(); |
} |
} {0} |
do_test func-12.7 { |
execsql { |
DROP TABLE t4; |
} |
} {} |
|
|
# Test that the auxdata API for scalar functions works. This test uses |
# a special user-defined function only available in test builds, |
# test_auxdata(). Function test_auxdata() takes any number of arguments. |
do_test func-13.1 { |
execsql { |
SELECT test_auxdata('hello world'); |
} |
} {0} |
|
do_test func-13.2 { |
execsql { |
CREATE TABLE t4(a, b); |
INSERT INTO t4 VALUES('abc', 'def'); |
INSERT INTO t4 VALUES('ghi', 'jkl'); |
} |
} {} |
do_test func-13.3 { |
execsql { |
SELECT test_auxdata('hello world') FROM t4; |
} |
} {0 1} |
do_test func-13.4 { |
execsql { |
SELECT test_auxdata('hello world', 123) FROM t4; |
} |
} {{0 0} {1 1}} |
do_test func-13.5 { |
execsql { |
SELECT test_auxdata('hello world', a) FROM t4; |
} |
} {{0 0} {1 0}} |
do_test func-13.6 { |
execsql { |
SELECT test_auxdata('hello'||'world', a) FROM t4; |
} |
} {{0 0} {1 0}} |
|
# Test that auxilary data is preserved between calls for SQL variables. |
do_test func-13.7 { |
set DB [sqlite3_connection_pointer db] |
set sql "SELECT test_auxdata( ? , a ) FROM t4;" |
set STMT [sqlite3_prepare $DB $sql -1 TAIL] |
sqlite3_bind_text $STMT 1 hello\000 -1 |
set res [list] |
while { "SQLITE_ROW"==[sqlite3_step $STMT] } { |
lappend res [sqlite3_column_text $STMT 0] |
} |
lappend res [sqlite3_finalize $STMT] |
} {{0 0} {1 0} SQLITE_OK} |
|
# Make sure that a function with a very long name is rejected |
do_test func-14.1 { |
catch { |
db function [string repeat X 254] {return "hello"} |
} |
} {0} |
do_test func-14.2 { |
catch { |
db function [string repeat X 256] {return "hello"} |
} |
} {1} |
|
do_test func-15.1 { |
catchsql {select test_error(NULL)} |
} {1 {SQL logic error or missing database}} |
do_test func-15.2 { |
catchsql {select test_error('this is the error message')} |
} {1 {this is the error message}} |
do_test func-15.3 { |
catchsql {select test_error('this is the error message',12)} |
} {1 {this is the error message}} |
do_test func-15.4 { |
db errorcode |
} {12} |
|
# Test the quote function for BLOB and NULL values. |
do_test func-16.1 { |
execsql { |
CREATE TABLE tbl2(a, b); |
} |
set STMT [sqlite3_prepare $::DB "INSERT INTO tbl2 VALUES(?, ?)" -1 TAIL] |
sqlite3_bind_blob $::STMT 1 abc 3 |
sqlite3_step $::STMT |
sqlite3_finalize $::STMT |
execsql { |
SELECT quote(a), quote(b) FROM tbl2; |
} |
} {X'616263' NULL} |
|
# Correctly handle function error messages that include %. Ticket #1354 |
# |
do_test func-17.1 { |
proc testfunc1 args {error "Error %d with %s percents %p"} |
db function testfunc1 ::testfunc1 |
catchsql { |
SELECT testfunc1(1,2,3); |
} |
} {1 {Error %d with %s percents %p}} |
|
# The SUM function should return integer results when all inputs are integer. |
# |
do_test func-18.1 { |
execsql { |
CREATE TABLE t5(x); |
INSERT INTO t5 VALUES(1); |
INSERT INTO t5 VALUES(-99); |
INSERT INTO t5 VALUES(10000); |
SELECT sum(x) FROM t5; |
} |
} {9902} |
ifcapable floatingpoint { |
do_test func-18.2 { |
execsql { |
INSERT INTO t5 VALUES(0.0); |
SELECT sum(x) FROM t5; |
} |
} {9902.0} |
} |
|
# The sum of nothing is NULL. But the sum of all NULLs is NULL. |
# |
# The TOTAL of nothing is 0.0. |
# |
do_test func-18.3 { |
execsql { |
DELETE FROM t5; |
SELECT sum(x), total(x) FROM t5; |
} |
} {{} 0.0} |
do_test func-18.4 { |
execsql { |
INSERT INTO t5 VALUES(NULL); |
SELECT sum(x), total(x) FROM t5 |
} |
} {{} 0.0} |
do_test func-18.5 { |
execsql { |
INSERT INTO t5 VALUES(NULL); |
SELECT sum(x), total(x) FROM t5 |
} |
} {{} 0.0} |
do_test func-18.6 { |
execsql { |
INSERT INTO t5 VALUES(123); |
SELECT sum(x), total(x) FROM t5 |
} |
} {123 123.0} |
|
# Ticket #1664, #1669, #1670, #1674: An integer overflow on SUM causes |
# an error. The non-standard TOTAL() function continues to give a helpful |
# result. |
# |
do_test func-18.10 { |
execsql { |
CREATE TABLE t6(x INTEGER); |
INSERT INTO t6 VALUES(1); |
INSERT INTO t6 VALUES(1<<62); |
SELECT sum(x) - ((1<<62)+1) from t6; |
} |
} 0 |
do_test func-18.11 { |
execsql { |
SELECT typeof(sum(x)) FROM t6 |
} |
} integer |
ifcapable floatingpoint { |
do_test func-18.12 { |
catchsql { |
INSERT INTO t6 VALUES(1<<62); |
SELECT sum(x) - ((1<<62)*2.0+1) from t6; |
} |
} {1 {integer overflow}} |
do_test func-18.13 { |
execsql { |
SELECT total(x) - ((1<<62)*2.0+1) FROM t6 |
} |
} 0.0 |
} |
ifcapable !floatingpoint { |
do_test func-18.12 { |
catchsql { |
INSERT INTO t6 VALUES(1<<62); |
SELECT sum(x) - ((1<<62)*2+1) from t6; |
} |
} {1 {integer overflow}} |
do_test func-18.13 { |
execsql { |
SELECT total(x) - ((1<<62)*2+1) FROM t6 |
} |
} 0.0 |
} |
if {[working_64bit_int]} { |
do_test func-18.14 { |
execsql { |
SELECT sum(-9223372036854775805); |
} |
} -9223372036854775805 |
} |
ifcapable compound&&subquery { |
|
do_test func-18.15 { |
catchsql { |
SELECT sum(x) FROM |
(SELECT 9223372036854775807 AS x UNION ALL |
SELECT 10 AS x); |
} |
} {1 {integer overflow}} |
if {[working_64bit_int]} { |
do_test func-18.16 { |
catchsql { |
SELECT sum(x) FROM |
(SELECT 9223372036854775807 AS x UNION ALL |
SELECT -10 AS x); |
} |
} {0 9223372036854775797} |
do_test func-18.17 { |
catchsql { |
SELECT sum(x) FROM |
(SELECT -9223372036854775807 AS x UNION ALL |
SELECT 10 AS x); |
} |
} {0 -9223372036854775797} |
} |
do_test func-18.18 { |
catchsql { |
SELECT sum(x) FROM |
(SELECT -9223372036854775807 AS x UNION ALL |
SELECT -10 AS x); |
} |
} {1 {integer overflow}} |
do_test func-18.19 { |
catchsql { |
SELECT sum(x) FROM (SELECT 9 AS x UNION ALL SELECT -10 AS x); |
} |
} {0 -1} |
do_test func-18.20 { |
catchsql { |
SELECT sum(x) FROM (SELECT -9 AS x UNION ALL SELECT 10 AS x); |
} |
} {0 1} |
do_test func-18.21 { |
catchsql { |
SELECT sum(x) FROM (SELECT -10 AS x UNION ALL SELECT 9 AS x); |
} |
} {0 -1} |
do_test func-18.22 { |
catchsql { |
SELECT sum(x) FROM (SELECT 10 AS x UNION ALL SELECT -9 AS x); |
} |
} {0 1} |
|
} ;# ifcapable compound&&subquery |
|
# Integer overflow on abs() |
# |
if {[working_64bit_int]} { |
do_test func-18.31 { |
catchsql { |
SELECT abs(-9223372036854775807); |
} |
} {0 9223372036854775807} |
} |
do_test func-18.32 { |
catchsql { |
SELECT abs(-9223372036854775807-1); |
} |
} {1 {integer overflow}} |
|
# The MATCH function exists but is only a stub and always throws an error. |
# |
do_test func-19.1 { |
execsql { |
SELECT match(a,b) FROM t1 WHERE 0; |
} |
} {} |
do_test func-19.2 { |
catchsql { |
SELECT 'abc' MATCH 'xyz'; |
} |
} {1 {unable to use function MATCH in the requested context}} |
do_test func-19.3 { |
catchsql { |
SELECT 'abc' NOT MATCH 'xyz'; |
} |
} {1 {unable to use function MATCH in the requested context}} |
do_test func-19.4 { |
catchsql { |
SELECT match(1,2,3); |
} |
} {1 {wrong number of arguments to function match()}} |
|
# Soundex tests. |
# |
if {![catch {db eval {SELECT soundex('hello')}}]} { |
set i 0 |
foreach {name sdx} { |
euler E460 |
EULER E460 |
Euler E460 |
ellery E460 |
gauss G200 |
ghosh G200 |
hilbert H416 |
Heilbronn H416 |
knuth K530 |
kant K530 |
Lloyd L300 |
LADD L300 |
Lukasiewicz L222 |
Lissajous L222 |
A A000 |
12345 ?000 |
} { |
incr i |
do_test func-20.$i { |
execsql {SELECT soundex($name)} |
} $sdx |
} |
} |
|
# Tests of the REPLACE function. |
# |
do_test func-21.1 { |
catchsql { |
SELECT replace(1,2); |
} |
} {1 {wrong number of arguments to function replace()}} |
do_test func-21.2 { |
catchsql { |
SELECT replace(1,2,3,4); |
} |
} {1 {wrong number of arguments to function replace()}} |
do_test func-21.3 { |
execsql { |
SELECT typeof(replace("This is the main test string", NULL, "ALT")); |
} |
} {null} |
do_test func-21.4 { |
execsql { |
SELECT typeof(replace(NULL, "main", "ALT")); |
} |
} {null} |
do_test func-21.5 { |
execsql { |
SELECT typeof(replace("This is the main test string", "main", NULL)); |
} |
} {null} |
do_test func-21.6 { |
execsql { |
SELECT replace("This is the main test string", "main", "ALT"); |
} |
} {{This is the ALT test string}} |
do_test func-21.7 { |
execsql { |
SELECT replace("This is the main test string", "main", "larger-main"); |
} |
} {{This is the larger-main test string}} |
do_test func-21.8 { |
execsql { |
SELECT replace("aaaaaaa", "a", "0123456789"); |
} |
} {0123456789012345678901234567890123456789012345678901234567890123456789} |
|
ifcapable tclvar { |
do_test func-21.9 { |
# Attempt to exploit a buffer-overflow that at one time existed |
# in the REPLACE function. |
set ::str "[string repeat A 29998]CC[string repeat A 35537]" |
set ::rep [string repeat B 65536] |
execsql { |
SELECT LENGTH(REPLACE($::str, 'C', $::rep)); |
} |
} [expr 29998 + 2*65536 + 35537] |
} |
|
# Tests for the TRIM, LTRIM and RTRIM functions. |
# |
do_test func-22.1 { |
catchsql {SELECT trim(1,2,3)} |
} {1 {wrong number of arguments to function trim()}} |
do_test func-22.2 { |
catchsql {SELECT ltrim(1,2,3)} |
} {1 {wrong number of arguments to function ltrim()}} |
do_test func-22.3 { |
catchsql {SELECT rtrim(1,2,3)} |
} {1 {wrong number of arguments to function rtrim()}} |
do_test func-22.4 { |
execsql {SELECT trim(' hi ');} |
} {hi} |
do_test func-22.5 { |
execsql {SELECT ltrim(' hi ');} |
} {{hi }} |
do_test func-22.6 { |
execsql {SELECT rtrim(' hi ');} |
} {{ hi}} |
do_test func-22.7 { |
execsql {SELECT trim(' hi ','xyz');} |
} {{ hi }} |
do_test func-22.8 { |
execsql {SELECT ltrim(' hi ','xyz');} |
} {{ hi }} |
do_test func-22.9 { |
execsql {SELECT rtrim(' hi ','xyz');} |
} {{ hi }} |
do_test func-22.10 { |
execsql {SELECT trim('xyxzy hi zzzy','xyz');} |
} {{ hi }} |
do_test func-22.11 { |
execsql {SELECT ltrim('xyxzy hi zzzy','xyz');} |
} {{ hi zzzy}} |
do_test func-22.12 { |
execsql {SELECT rtrim('xyxzy hi zzzy','xyz');} |
} {{xyxzy hi }} |
do_test func-22.13 { |
execsql {SELECT trim(' hi ','');} |
} {{ hi }} |
if {[db one {PRAGMA encoding}]=="UTF-8"} { |
do_test func-22.14 { |
execsql {SELECT hex(trim(x'c280e1bfbff48fbfbf6869',x'6162e1bfbfc280'))} |
} {F48FBFBF6869} |
do_test func-22.15 { |
execsql {SELECT hex(trim(x'6869c280e1bfbff48fbfbf61', |
x'6162e1bfbfc280f48fbfbf'))} |
} {6869} |
do_test func-22.16 { |
execsql {SELECT hex(trim(x'ceb1ceb2ceb3',x'ceb1'));} |
} {CEB2CEB3} |
} |
do_test func-22.20 { |
execsql {SELECT typeof(trim(NULL));} |
} {null} |
do_test func-22.21 { |
execsql {SELECT typeof(trim(NULL,'xyz'));} |
} {null} |
do_test func-22.22 { |
execsql {SELECT typeof(trim('hello',NULL));} |
} {null} |
|
# This is to test the deprecated sqlite3_aggregate_count() API. |
# |
ifcapable deprecated { |
do_test func-23.1 { |
sqlite3_create_aggregate db |
execsql { |
SELECT legacy_count() FROM t6; |
} |
} {3} |
} |
|
# The group_concat() function. |
# |
do_test func-24.1 { |
execsql { |
SELECT group_concat(t1) FROM tbl1 |
} |
} {this,program,is,free,software} |
do_test func-24.2 { |
execsql { |
SELECT group_concat(t1,' ') FROM tbl1 |
} |
} {{this program is free software}} |
do_test func-24.3 { |
execsql { |
SELECT group_concat(t1,' ' || rowid || ' ') FROM tbl1 |
} |
} {{this 2 program 3 is 4 free 5 software}} |
do_test func-24.4 { |
execsql { |
SELECT group_concat(NULL,t1) FROM tbl1 |
} |
} {{}} |
do_test func-24.5 { |
execsql { |
SELECT group_concat(t1,NULL) FROM tbl1 |
} |
} {thisprogramisfreesoftware} |
do_test func-24.6 { |
execsql { |
SELECT 'BEGIN-'||group_concat(t1) FROM tbl1 |
} |
} {BEGIN-this,program,is,free,software} |
|
# Ticket #3179: Make sure aggregate functions can take many arguments. |
# None of the built-in aggregates do this, so use the md5sum() from the |
# test extensions. |
# |
unset -nocomplain midargs |
set midargs {} |
unset -nocomplain midres |
set midres {} |
unset -nocomplain result |
for {set i 1} {$i<[sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG -1]} {incr i} { |
append midargs ,'/$i' |
append midres /$i |
set result [md5 \ |
"this${midres}program${midres}is${midres}free${midres}software${midres}"] |
set sql "SELECT md5sum(t1$midargs) FROM tbl1" |
do_test func-24.7.$i { |
db eval $::sql |
} $result |
} |
|
# Ticket #3806. If the initial string in a group_concat is an empty |
# string, the separator that follows should still be present. |
# |
do_test func-24.8 { |
execsql { |
SELECT group_concat(CASE t1 WHEN 'this' THEN '' ELSE t1 END) FROM tbl1 |
} |
} {,program,is,free,software} |
do_test func-24.9 { |
execsql { |
SELECT group_concat(CASE WHEN t1!='software' THEN '' ELSE t1 END) FROM tbl1 |
} |
} {,,,,software} |
|
# Ticket #3923. Initial empty strings have a separator. But initial |
# NULLs do not. |
# |
do_test func-24.10 { |
execsql { |
SELECT group_concat(CASE t1 WHEN 'this' THEN null ELSE t1 END) FROM tbl1 |
} |
} {program,is,free,software} |
do_test func-24.11 { |
execsql { |
SELECT group_concat(CASE WHEN t1!='software' THEN null ELSE t1 END) FROM tbl1 |
} |
} {software} |
do_test func-24.12 { |
execsql { |
SELECT group_concat(CASE t1 WHEN 'this' THEN '' |
WHEN 'program' THEN null ELSE t1 END) FROM tbl1 |
} |
} {,is,free,software} |
|
|
# Use the test_isolation function to make sure that type conversions |
# on function arguments do not effect subsequent arguments. |
# |
do_test func-25.1 { |
execsql {SELECT test_isolation(t1,t1) FROM tbl1} |
} {this program is free software} |
|
# Try to misuse the sqlite3_create_function() interface. Verify that |
# errors are returned. |
# |
do_test func-26.1 { |
abuse_create_function db |
} {} |
|
# The previous test (func-26.1) registered a function with a very long |
# function name that takes many arguments and always returns NULL. Verify |
# that this function works correctly. |
# |
do_test func-26.2 { |
set a {} |
for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG} {incr i} { |
lappend a $i |
} |
db eval " |
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 ,]); |
" |
} {{}} |
do_test func-26.3 { |
set a {} |
for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG+1} {incr i} { |
lappend a $i |
} |
catchsql " |
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 ,]); |
" |
} {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}} |
do_test func-26.4 { |
set a {} |
for {set i 1} {$i<=$::SQLITE_MAX_FUNCTION_ARG-1} {incr i} { |
lappend a $i |
} |
catchsql " |
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 ,]); |
" |
} {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()}} |
do_test func-26.5 { |
catchsql " |
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); |
" |
} {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}} |
do_test func-26.6 { |
catchsql " |
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); |
" |
} {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}} |
|
do_test func-27.1 { |
catchsql {SELECT coalesce()} |
} {1 {wrong number of arguments to function coalesce()}} |
do_test func-27.2 { |
catchsql {SELECT coalesce(1)} |
} {1 {wrong number of arguments to function coalesce()}} |
do_test func-27.3 { |
catchsql {SELECT coalesce(1,2)} |
} {0 1} |
|
# Ticket 2d401a94287b5 |
# Unknown function in a DEFAULT expression causes a segfault. |
# |
do_test func-28.1 { |
db eval { |
CREATE TABLE t28(x, y DEFAULT(nosuchfunc(1))); |
} |
catchsql { |
INSERT INTO t28(x) VALUES(1); |
} |
} {1 {unknown function: nosuchfunc()}} |
|
finish_test |