SQLite 自定义函数,聚合,排序规则
1.使用自定义函数, 聚合以及排序规则的基本方法是使用回调函数.
这些注册的函数的生命周期只存在于应用程序中, 并不存储在数据库文件中, 因此需要在每个连接建立时注册才可以在 SQL 中进行使用.
2.排序规则
SQLite 对结果集中的字段进行排序时, SQLite 使用比较操作符如 < 或 >= 在字段内对值进行比较, 第一件事就是根据存储类对字段值进行排列.
然后在每种存储类中, 根据该类指定的方法进行排序. 存储类进行排序的顺序从前往后如下所示:
NULL 值 < INTEGER 和 REAL 值 < TEXT 值 < BLOB 值
(1) NULL 值具有最低的类值, 一个具有 NULL 存储类的值比所有其他的值都小(包括其他具有 NULL 存储类的值). 在 NULL 值之间, 没有具体的排序顺序.
(2) INTEGER 或 REAL 存储类值高于 NULL, 它们的类值相等. INTEGER 值和 REAL 值通过其数值进行比较.
(3) TEXT 存储类的值比 INTEGER 和 REAL 髙. 数值永远比字符串的值低. 当两个 TEXT 值进行比较时, 其值大小由该值中定义的 “排序法” 决定.
(4) BLOB 存储类具有最高的类值. 具有 BLOB 类的值大于其他所有类的值. BLOB 值之间在比较时使用 C 函数 memcmp.
对 TEXT 存储类的数据, 可以在创建表时指定字段排序规则, 也可以直接在查询中指定它们
CREATE TABLE Foo(x TEXT COLLATE NOCASE);
SELECT * FROM Foo ORDER BY x COLLATE NOCASE;
3.相关 API
(1) 注册自定义函数, 聚合函数
int sqlite3_create_function_v2(
sqlite3* db,
const char* zFunctionName,
int nArg,
int eTextRep,
void* pApp,
void (*xFunc)(sqlite3_context* ctx, int argc, sqlite3_value** argv),
void (*xStep)(sqlite3_context* ctx, int argc, sqlite3_value** argv),
void (*xFinal)(sqlite3_context* ctx),
void (*xDestroy)(void* pApp)
);
db: 数据库连接句柄, 函数和聚合的指定连接. 若要使用函数, 必须在连接上注册
zFunctionName: 在 SQL 语句中使用的函数,聚合名称, 长度限制 255 字节
nArg: 函数参数个数, 如果为-1, 表示可变长参数. SQLite 会强制检查参数个数, 确保传给自定义函数的参数格式是正确的
eTextRep: 首先文本编码格式, 如 SQLITE_UTF8, SQLITE_UTF16
pApp: 传递给回调函数的应用程序数据, 可供在 xFunc, xStep, xFinal 指定的回调函数中使用, 但必须使用特殊的 API 函数获取数据
xFunc: 回调函数
xStep: 聚合步骤函数, SQLite 处理聚合结果集中的每一行都要调用 xStep, 此函数内部处理聚合逻辑, 并保存到结果值中
xFinal: finalize 聚合函数, 处理完所有的行后 SQLite 调用该函数进行整个聚合汇总处理, 此函数内部一般设置聚合功能完成的结果
在自定义函数中,指定 xFunc, 同时 xStep 和 xFinal 设置为 nullptr. 自定义聚合函数则与前者刚好相反, 需设置 xStep 和 xFinal, 同时设置 xFunc 为 nullptr.
只要 nArg 指定参数的个数不同, 或 eTextRep 指定的编码不同, 同一个 zFunctionName 指定的函数就可以注册多个版本, SQLite 会自动选择最佳版本
xDestroy: 清理函数, 用于释放应用程序数据 pApp.
(2) int sqlite3_create_collation_v2(
sqlite3* db,
const char* zFunctionName,
int eTextRep,
void* pApp,
int (*xCompare)(void* pApp, int lLen, const void* lData, int rLen, const void* rData),
void (*xDestroy)(void* pApp)
);
各个参数的意义同 sqlite3_create_function_v2. 唯一不同的是比较函数指针 xCompare, 此参数指定用于比较的函数.
(3) void xFunc(sqlite3_context* ctx, int argc, sqlite3_value** argv);
ctx: 函数/聚合的上下文环境. 它保持特殊函数调用的实例状态, 通过它可以获得 sqlite3_create_function_v2 供的应用程序数据参数 pApp.
要获取该数据可以使用 void* sqlite3_user_data(sqlite3_context* ctx);
argc: 参数个数
argv: 参数值数组, 使用前需配合 argc 验证是否越界.
(4) int xCompare(void* pApp, int lLen, const void* lData, int rLen, const void* rData);
pApp: 在 sqlite3_create_collation_v2 设置的应用程序数据
lLen: 参数1的长度
lData: 参数1的指针
rLen: 参数2的长度
rData: 参数2的指针
PS: 参数1和参数2传入 const void*, 转换为 const char* 后, 字符串不一定是以 '\0' 结束. 因此类似以下的操作结果值不确定:
string lText{static_cast<const char*>(lData)};
应使用 string 的另一个构造函数
string lText{static_cast<const char*>(lData), 0, lLen};
(5) void *sqlite3_user_data(sqlite3_context* ctx);
取得 sqlite3_create_function_v2 调用时传入的 pApp 参数值. 对所有的回调函数, 此函数返回的参数是共享的.
(6) void* sqlite3_aggregate_context(sqlite3_context* ctx, int nBytes);
此函数为每个特定的实例分配状态, 第一次调用该函数时执行一个特殊的聚合函数, 分配 nBytes 字节内存, 并赋值为0.
注意, 分配内存后会赋值为0, 了解这一点非常重要, 这要求我们设置自定义类型保存聚合数据时, 必须是 POD 类型.
此后同一个 ctx 指定的上下文环境中的调用(同一个聚合的实例), 返回相同的数据, 即地址相同.
聚合函数必须要使用此函数, 因此聚合的目前, 就是可以在调用之间存储状态以便堆积数据.
当聚合完成 finalize()回调时, 由 SQLite 自动释放内存, 无须手动释放.
(7) Type sqlite3_value_Type(sqlite3_value* value);
返回 Type 类型的数据. 获取标量值:
double sqlite3_value_double(sqlite3_value*);
int sqlite3_value_int(sqlite3_value*);
sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
获取数组值:
int sqlite3_value_bytes(sqlite3_value*); // 返回 blob 缓冲区中数据长度
const void* sqlite3_value_blob(sqlite3_value*); // 返回 blob 缓冲区中数据指针
const unsigned char* sqlite3_value_text(sqlite3_value*); // 注意返回值不是 const char*
检查数据类型的函数:
int sqlite3_value_type(sqlite3_value*); // SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT
int sqlite3_value_numeric_type(sqlite3_value*);
配对使用 sqlite3_value_bytes 和 sqlite3_value_blob 函数, 就可以从结果中复制数据. 如:
int valueLen = sqlite3_value_bytes(argv[0]);
char* buf = static_cast<char*>(sqlite3_malloc(valueLen + 1));
(8) 设置结果, SQL 查询语句中返回的值
void sqlite3_result_text(sqlite3_context* ctx, const char* data, int len, void(*free)(void* data));
void sqlite3_result_blob(sqlite3_context* ctx, const void* data, int bytes, void(*free)(void* data));
void sqlite3_result_double(sqlite3_context*, double);
void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
void sqlite3_result_null(sqlite3_context*);
其中 pCleaner 指向释放内存的函数指针
设置出错信息
void sqlite3_result_error(sqlite3_context*, const char*, int);
void sqlite3_result_error_toobig(sqlite3_context*);
void sqlite3_result_error_nomem(sqlite3_context*);
void sqlite3_result_error_code(sqlite3_context*, int);
清理内存
void free(void* p); 用户自定义函数调用完成后, 调用指定的清理函数释放内存. 即 sqlite3_result_text 和 sqlite3_result_blob 的实参 data
预定义清理函数
#define SQLITE_STATIC ((void(*)(void *))0)
#define SQLITE_TRANSIENT ((void(*)(void*))-l)
SQLITE_STATIC 意味着数组内存驻留在非托管空间, SQLite 不需要数据副本, 也不会试图清理它.
SQLITE_TRANSIENT 提示数组数据有可能改变, SQLite 使用 sqlite3_malloc 为自己复制一份数据.
(9) 内存分配与释放
void* sqlite3_malloc(int);
void* sqlite3_realloc(void*, int);
void sqlite3_free(void*);
//////////////////////////////////////////////////////////////////////////
// 测试代码
#include <cassert>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <string>
#include "Memory.h"
#include "Rand.h"
#include "sqlite3.h" using namespace std; //#define OUTPUT_FILE #if defined(OUTPUT_FILE)
#define ERR fout << "[" << __func__ << ":" << __LINE__ << "] Error! "
#define INFO fout
#define DEBUG fout
#else
#define ERR cerr << "[" << __func__ << ":" << __LINE__ << "] Error! "
#define INFO cout
#define DEBUG cerr
#endif
#define MEMINFO(msg) Memory::print(msg) #if defined(OUTPUT_FILE)
fstream fout;
#endif void initOutputStream()
{
#if defined(OUTPUT_FILE)
fout.open("F:/Sqlite/mysql/log.txt", fstream::ios_base::out | fstream::ios_base::trunc);
#endif
} void testClean(void* p)
{
DEBUG << "clean:" << reinterpret_cast<int>(p) << endl;
} string getString(sqlite3_value* value)
{
const char* text = reinterpret_cast<const char*>(sqlite3_value_text(value));
return text ? string{text} : "";
} /**
* 将字符串拆分成非全数字组成的前缀,和全数字组成的后缀
*/
bool splitName(const string& text, string& prefix, string& suffix)
{
regex reg("^(.*[^\\d]+)(\\d+)$|^(\\d+)$");
smatch match;
if (regex_match(text, match, reg))
{
prefix = match.str();
suffix = prefix.empty() ? match.str() : match.str();
return true;
}
prefix = text;
return false;
} /**
* 去掉字符串前面的0
*/
string trimPrefixZero(const string& text)
{
size_t pos = text.find_first_not_of('0');
if (string::npos != pos && != pos)
{
return text.substr(pos);
}
return text;
} /**
* 比较两个数字字符串序列的大小
*/
int compareDigit(const string& lhs, const string& rhs)
{
string lText = trimPrefixZero(lhs);
string rText = trimPrefixZero(rhs);
if (lText.length() != rText.length())
{
return lText.length() - rText.length();
}
for (size_t i = ; i < lText.length(); ++i)
{
if (lText.at(i) != rText.at(i))
{
return lText.at(i) - rText.at(i);
}
}
return ;
} sqlite3* openDB(const string& file)
{
sqlite3* db{};
int ret = sqlite3_open_v2(file.c_str(), &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, );
if (SQLITE_OK != ret)
{
ERR << "sqlite3_open_v2 failed." << endl;
return nullptr;
}
return db;
} bool closeDB(sqlite3* db)
{
int ret = sqlite3_close_v2(db);
if (SQLITE_OK != ret)
{
ERR << "sqlite3_close_v2 failed." << endl;
return false;
}
return true;
} bool execSQL(sqlite3* db, const string& sql)
{
char* errmsg{};
int ret = sqlite3_exec(db, sql.c_str(), , , &errmsg);
if (SQLITE_OK != ret)
{
ERR << "sqlite3_exec failed." << errmsg << endl;
}
sqlite3_free(errmsg);
return SQLITE_OK == ret;
} bool printSQL(sqlite3* db, const string& sql)
{
int ret{};
sqlite3_stmt* stmt{};
ret = sqlite3_prepare_v2(db, sql.c_str(), sql.length(), &stmt, );
if (SQLITE_OK != ret)
{
ERR << "sqlite3_prepare_v2 failed." << sqlite3_errmsg(db) << endl;
return false;
} INFO << sql << endl;
int colCount = sqlite3_column_count(stmt);
if (colCount > )
{
for (int col = ; col < colCount; )
{
INFO << sqlite3_column_name(stmt, col);
if (++col != colCount)
{
INFO << '\t';
}
}
INFO << endl;
} do
{
ret = sqlite3_step(stmt);
if (SQLITE_ROW != ret)
{
break;
}
for (int col = ; col < colCount; )
{
const char* text = reinterpret_cast<const char*>(sqlite3_column_text(stmt, col));
INFO << (text ? text : "");
if (++col != colCount)
{
INFO << '\t';
}
}
INFO << endl;
} while (true);
if (SQLITE_DONE != ret)
{
ERR << "sqlite3_step failed." << sqlite3_errmsg(db) << endl;
} ret = sqlite3_finalize(stmt);
if (SQLITE_OK != ret)
{
ERR << "sqlite3_finalize failed." << sqlite3_errmsg(db) << endl;
return false;
} return true;
} // SQLite 函数
void echo(sqlite3_context* ctx, int argc, sqlite3_value** argv)
{
assert( == argc);
// DEBUG << "user data:" << reinterpret_cast<int>(sqlite3_user_data(ctx)) << endl;
const char* text{reinterpret_cast<const char*>(sqlite3_value_text(argv[]))};
sqlite3_result_text(ctx, text, -, );
} void strcat_column(sqlite3_context* ctx, int argc, sqlite3_value** argv)
{
const char* delimiter{"\t"};
const int DELIMITER_LEN = strlen(delimiter);
int len = ;
for (int i = ; i < argc; ++i)
{
len += sqlite3_value_bytes(argv[i]);
len += DELIMITER_LEN;
}
char* buf = static_cast<char*>(sqlite3_malloc(len));
int pos = ;
for (int i = ; i < argc; )
{
int bytes = sqlite3_value_bytes(argv[i]);
memcpy(buf + pos, sqlite3_value_blob(argv[i]), bytes);
pos += bytes; if (++i != argc)
{
memcpy(buf + pos, delimiter, DELIMITER_LEN);
pos += DELIMITER_LEN;
}
}
buf[pos] = ;
sqlite3_result_text(ctx, buf, -, );
} /**
* 找出值为匹配前缀,并且后缀在指定范围内的值
*/
void peekName(sqlite3_context* ctx, int argc, sqlite3_value** argv)
{
assert( == argc); bool isFound{false};
string vPrefix;
string vSuffix;
string value = getString(argv[]);
if (splitName(value, vPrefix, vSuffix))
{
string prefix = getString(argv[]);
if (vPrefix == prefix)
{
string suffixFrom = getString(argv[]);
string suffixTo = getString(argv[]);
if (compareDigit(vSuffix, suffixFrom) >= && compareDigit(vSuffix, suffixTo) <= )
{
isFound = true;
}
}
} sqlite3_result_int(ctx, isFound);
} // SQLite 聚合函数
struct AggregateCharData
{
int len{};
char* buf{};
}; void strcat_step(sqlite3_context* ctx, int argc, sqlite3_value** argv)
{
assert( == argc);
AggregateCharData* pData{static_cast<AggregateCharData*>(sqlite3_aggregate_context(ctx, sizeof(AggregateCharData)))}; if (!pData)
{
ERR << "Alloc AggregateData failed!" << endl;
return;
} int valueLen = sqlite3_value_bytes(argv[]);
if (!pData->buf)
{
pData->buf = static_cast<char*>(sqlite3_malloc(valueLen + ));
}
else
{
int delimiterLen = sqlite3_value_bytes(argv[]);
int len = valueLen + delimiterLen + pData->len + ;
pData->buf = static_cast<char*>(sqlite3_realloc(pData->buf, len));
memcpy(pData->buf + pData->len, sqlite3_value_blob(argv[]), delimiterLen);
pData->len += delimiterLen;
}
memcpy(pData->buf + pData->len, sqlite3_value_blob(argv[]), valueLen);
pData->len += valueLen;
} void strcat_final(sqlite3_context* ctx)
{
AggregateCharData* pData{static_cast<AggregateCharData*>(sqlite3_aggregate_context(ctx, sizeof(AggregateCharData)))};
if (!pData || !pData->buf)
{
sqlite3_result_text(ctx, pData->buf, pData->len, sqlite3_free);
}
} /**
* SQLite 排序示例,将值拆分成非全数字组成的前缀,和全数字组成的后缀,前缀不同时,按字典排序;前缀相同时,后缀按数字大小排序
**/
int compareName(void*, int lhsLen, const void* lhsData, int rhsLen, const void* rhsData)
{
string lText(static_cast<const char*>(lhsData), , lhsLen);
string lPrefix;
string lSuffix;
if (!splitName(lText, lPrefix, lSuffix))
{
return ;
} string rText(static_cast<const char*>(rhsData), , rhsLen);
string rPrefix;
string rSuffix;
if (!splitName(rText, rPrefix, rSuffix))
{
return ;
} if (lPrefix != rPrefix)
{
return lPrefix.compare(rPrefix);
} return compareDigit(lSuffix, rSuffix);
} string randNumString()
{
static const string NUMBERS{""};
string ret;
int len = Rand::rand(, );
for (int i = ; i < len; ++i)
{
ret.push_back(NUMBERS.at(Rand::rand(, NUMBERS.length() - )));
}
return ret;
} string randPrefix()
{
static const string PREFIX_STR{""
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-"};
string ret;
int len = Rand::rand(, );
for (int i = ; i < len; ++i)
{
ret.push_back(PREFIX_STR.at(Rand::rand(, PREFIX_STR.length() - )));
}
return ret;
} void insertTestData(sqlite3* db)
{
execSQL(db, "INSERT INTO Foo VALUES(null, 1, 2);");
execSQL(db, "INSERT INTO Foo VALUES(null, 10.5, 20.1);");
execSQL(db, "INSERT INTO Foo VALUES(null, 'abc', 'hehe');"); vector<string> prefixs{randPrefix(), randPrefix(), randPrefix(), randPrefix()};
ostringstream stm;
for (int i = ; i < ; ++i)
{
string prefix = prefixs.at(Rand::rand(, prefixs.size() - ));
stm.str("");
stm << "INSERT INTO Foo VALUES(null, '" << prefix << randNumString() << "', "
<< Rand::rand(, ) << ");";
execSQL(db, stm.str()); stm.str("");
stm << "INSERT INTO Foo VALUES(null, '" << prefix << randNumString() << "', "
<< Rand::rand(, ) << ");";
execSQL(db, stm.str()); stm.str("");
stm << "INSERT INTO Foo VALUES(null, '" << prefix << randNumString() << "', "
<< Rand::rand(, ) << ");";
execSQL(db, stm.str());
}
} int main(int, char**)
{
initOutputStream(); MEMINFO("start");
sqlite3* db = openDB("Foo.db"); int ret{};
MEMINFO("create table");
execSQL(db, "CREATE TABLE IF NOT EXISTS Foo"
"(_id INTEGER PRIMARY KEY, name TEXT, info TEXT);"); // insertTestData(db); MEMINFO("query all");
printSQL(db, "SELECT * FROM Foo;"); MEMINFO("set echo");
ret = sqlite3_create_function_v2(db, "echo", , SQLITE_UTF8, reinterpret_cast<void*>(), echo, , , testClean);
if (SQLITE_OK != ret)
{
ERR << "sqlite3_create_function_v2 -> echo." << sqlite3_errmsg(db) << endl;
}
MEMINFO("query using echo");
printSQL(db, "SELECT echo('Hello SQLite!') AS replay;");
printSQL(db, "SELECT _id, echo(name) AS name FROM Foo;"); MEMINFO("set strcat_column");
ret = sqlite3_create_function_v2(db, "strcat_column", -, SQLITE_UTF8, , strcat_column, , , );
if (SQLITE_OK != ret)
{
ERR << "sqlite3_create_function_v2 -> strcat_column." << sqlite3_errmsg(db) << endl;
}
MEMINFO("query using strcat_column");
printSQL(db, "SELECT strcat_column(_id, name, info) AS list FROM Foo;"); MEMINFO("set strcat");
ret = sqlite3_create_function_v2(db, "strcat", , SQLITE_UTF8, , , strcat_step, strcat_final, );
MEMINFO("query using strcat");
if (SQLITE_OK != ret)
{
ERR << "sqlite3_create_function_v2 -> strcat_column." << sqlite3_errmsg(db) << endl;
}
printSQL(db, "SELECT strcat(_id, ',') AS ids FROM Foo;");
printSQL(db, "SELECT strcat(name, ',') AS names FROM Foo;");
printSQL(db, "SELECT strcat(info, ',') AS infos FROM Foo;"); MEMINFO("set peekName");
ret = sqlite3_create_function_v2(db, "peekName", , SQLITE_UTF8, , peekName, , , );
MEMINFO("query using peekName");
if (SQLITE_OK != ret)
{
ERR << "sqlite3_create_function_v2 -> peekName." << sqlite3_errmsg(db) << endl;
}
printSQL(db, "SELECT * FROM Foo WHERE peekName(name, '9Y58h', 293, 62804);"); MEMINFO("set compareName");
ret = sqlite3_create_collation_v2(db, "compareName", SQLITE_UTF8, reinterpret_cast<void*>(), compareName, testClean);
MEMINFO("query using compareName");
if (SQLITE_OK != ret)
{
ERR << "sqlite3_create_collation_v2 -> compareName." << sqlite3_errmsg(db) << endl;
}
printSQL(db, "SELECT * FROM Foo ORDER BY name collate compareName;"); MEMINFO("close db");
closeDB(db); MEMINFO("end");
return ;
}
//////////////////////////////////////////////////////////////////////////
// 随机数 #ifndef RAND_H
#define RAND_H #include <random> class Rand
{
public:
static int rand(int minValue, int maxValue); private:
static std::default_random_engine DEFAULT_ENGINE;
}; #endif // RAND_H #include "Rand.h"
#include <ctime> std::default_random_engine Rand::DEFAULT_ENGINE(time()); int Rand::rand(int minValue, int maxValue)
{
std::uniform_int_distribution<int> d(minValue, maxValue);
return d(DEFAULT_ENGINE);
}
//////////////////////////////////////////////////////////////////////////
// 内存打印工具 #ifndef MEMORY_H
#define MEMORY_H #include <string> using std::string; class Memory
{
public:
static void print(const string& tag = ""); private:
static string format(long long);
static long long m_prevAvaiPhys;
}; #endif // MEMORY_H #include "Memory.h"
#include <iostream>
#include <sstream>
#include "windows.h" long long Memory::m_prevAvaiPhys{}; void Memory::print(const string& tag)
{
MEMORYSTATUSEX mem{};
mem.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&mem);
std::cout << "virtual:" << format(mem.ullAvailVirtual) << "/" << format(mem.ullTotalVirtual)
<< " physical:" << format(mem.ullAvailPhys) << "/" << format(mem.ullTotalPhys); if ( != m_prevAvaiPhys)
{
std::cout << ", reduce physical:" << (long long)(m_prevAvaiPhys - mem.ullAvailPhys) << "B";
}
m_prevAvaiPhys = mem.ullAvailPhys; std::cout << " [" << tag << "]" << std::endl;
} string Memory::format(long long bytes)
{
std::ostringstream stm;
//stm << (bytes >> 20) << "MB";
stm << (bytes >> ) << "KB";
return stm.str();
}