void registerEncodingExtensions(sqlite3* db) {
sqlite3_create_function(db,
"conditional_to_base64",
1,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
nullptr,
sqliteB64ConditionalEncFunc,
nullptr,
nullptr);
sqlite3_create_function(db,
"to_base64",
1,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
nullptr,
sqliteB64EncFunc,
nullptr,
nullptr);
sqlite3_create_function(db,
"from_base64",
1,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
nullptr,
sqliteB64DecFunc,
nullptr,
nullptr);
}
/*
** Set up SQL objects in database db used to access the contents of
** the hash table pointed to by argument pHash. The hash table must
** been initialised to use string keys, and to take a private copy
** of the key when a value is inserted. i.e. by a call similar to:
**
** sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
**
** This function adds a scalar function (see header comment above
** scalarFunc() in this file for details) and, if ENABLE_TABLE is
** defined at compilation time, a temporary virtual table (see header
** comment above struct HashTableVtab) to the database schema. Both
** provide read/write access to the contents of *pHash.
**
** The third argument to this function, zName, is used as the name
** of both the scalar and, if created, the virtual table.
*/
int sqlite3Fts3InitHashTable(
sqlite3 *db,
fts3Hash *pHash,
const char *zName
){
int rc = SQLITE_OK;
void *p = (void *)pHash;
const int any = SQLITE_ANY;
char *zTest = 0;
char *zTest2 = 0;
#ifdef SQLITE_TEST
void *pdb = (void *)db;
zTest = sqlite3_mprintf("%s_test", zName);
zTest2 = sqlite3_mprintf("%s_internal_test", zName);
if( !zTest || !zTest2 ){
rc = SQLITE_NOMEM;
}
#endif
if( rc!=SQLITE_OK
|| (rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0))
|| (rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0))
#ifdef SQLITE_TEST
|| (rc = sqlite3_create_function(db, zTest, 2, any, p, testFunc, 0, 0))
|| (rc = sqlite3_create_function(db, zTest, 3, any, p, testFunc, 0, 0))
|| (rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0))
#endif
);
sqlite3_free(zTest);
sqlite3_free(zTest2);
return rc;
}
static int registerTestFunctions(sqlite3 *db){
static const struct {
char *zName;
signed char nArg;
unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */
void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
} aFuncs[] = {
{ "randstr", 2, SQLITE_UTF8, randStr },
{ "test_destructor", 1, SQLITE_UTF8, test_destructor},
#ifndef SQLITE_OMIT_UTF16
{ "test_destructor16", 1, SQLITE_UTF8, test_destructor16},
{ "hex_to_utf16be", 1, SQLITE_UTF8, testHexToUtf16be},
{ "hex_to_utf16le", 1, SQLITE_UTF8, testHexToUtf16le},
#endif
{ "hex_to_utf8", 1, SQLITE_UTF8, testHexToUtf8},
{ "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count},
{ "test_auxdata", -1, SQLITE_UTF8, test_auxdata},
{ "test_error", 1, SQLITE_UTF8, test_error},
{ "test_error", 2, SQLITE_UTF8, test_error},
{ "test_eval", 1, SQLITE_UTF8, test_eval},
{ "test_isolation", 2, SQLITE_UTF8, test_isolation},
{ "test_counter", 1, SQLITE_UTF8, counterFunc},
};
int i;
for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0);
}
sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0,
test_agg_errmsg16_step, test_agg_errmsg16_final);
return SQLITE_OK;
}
jint Java_com_tencent_mobileqq_persistence_FTSDatatbaseDao_initFTS(JNIEnv* env, jobject thiz)
{
int errCode = sqlite3_open_v2(DB_FILE, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't open database IndexQQMsg.db, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_exec(db, "PRAGMA cache_size=4000;", NULL, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't set PRAGMA cache_size = 4000, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_create_function(db, "qqcompress", 1, SQLITE_UTF8, NULL, qqcompress, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create function, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
errCode = sqlite3_create_function(db, "qquncompress", 1, SQLITE_UTF8, NULL, qquncompress, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create function, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
char* sql = "CREATE VIRTUAL TABLE IF NOT EXISTS IndexMsg USING fts4(type, content, contentindex, oid, ext1, ext2，ext3，exts, compress=qqcompress, uncompress=qquncompress);";
// char* sql = "CREATE VIRTUAL TABLE IF NOT EXISTS IndexMsg USING fts4(type, content, contentindex, oid, ext1, ext2，ext3，exts);";
errCode = sqlite3_exec(db, sql, NULL, NULL, NULL);
if (SQLITE_OK != errCode)
{
logError("Can't create virtual table IndexMsg, ", sqlite3_errmsg(db));
sqlite3_close(db);
return errCode;
}
#ifdef ZIP
const char* version = zlibVersion();
logInfo("FTS init zlib version = ", version);
#endif
logInfo("FTS init...", NULL);
return 0;
}
/*
** Register the SQL functions.
*/
static int cflRegister(sqlite3 *db){
int rc = sqlite3_create_function(
db, "sqlite_readint32", -1, SQLITE_UTF8, 0, readint_function, 0, 0
);
if( rc!=SQLITE_OK ) return rc;
rc = sqlite3_create_function(
db, "checkfreelist", 1, SQLITE_UTF8, 0, checkfreelist_function, 0, 0
);
return rc;
}
int db_get_table(char *command)
{
sqlite3 *db;
char *zErrMsg = 0;
int rc;
#if (GTKVER == 3)
G_LOCK(table_mutex);
#else
g_static_mutex_lock(&table_mutex);
#endif
if (tablep) {
g_print("ERROR: TABLE NOT CLOSED BEFORE OPENING!\n");
sqlite3_free_table(tablep);
}
tablep = NULL;
G_LOCK(db);
rc = sqlite3_open(db_name, &db);
if (rc) {
fprintf(stderr, "Can't open database: %s\n",
sqlite3_errmsg(db));
G_UNLOCK(db);
#if (GTKVER == 3)
G_UNLOCK(table_mutex);
#else
g_static_mutex_unlock(&table_mutex);
#endif
return -1;
}
sqlite3_create_function(db, "utf8error", 1, SQLITE_UTF8, NULL, utf8error, NULL, NULL);
sqlite3_create_function(db, "getweight", 1, SQLITE_UTF8, NULL, getweight, NULL, NULL);
//g_print("\nSQL: %s:\n %s\n", db_name, cmd);
rc = sqlite3_get_table(db, command, &tablep, &tablerows, &tablecols, &zErrMsg);
if (rc != SQLITE_OK && zErrMsg) {
g_print("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
sqlite3_close(db);
G_UNLOCK(db);
#if (GTKVER == 3)
G_UNLOCK(table_mutex);
#else
g_static_mutex_unlock(&table_mutex);
#endif
return -1;
}
sqlite3_close(db);
G_UNLOCK(db);
return tablerows;
}
/*
** Register the query expression parser test function fts3_exprtest()
** with database connection db.
*/
int sqlite3Fts3ExprInitTestInterface(sqlite3* db){
int rc = sqlite3_create_function(
db, "fts3_exprtest", -1, SQLITE_UTF8, 0, fts3ExprTest, 0, 0
);
if( rc==SQLITE_OK ){
rc = sqlite3_create_function(db, "fts3_exprtest_rebalance",
-1, SQLITE_UTF8, (void *)1, fts3ExprTest, 0, 0
);
}
return rc;
}
int register_sqlite_funcs(sqlite3 *db, sqlite_registration_func_t *reg_funcs)
{
int lpc;
assert(db != NULL);
assert(reg_funcs != NULL);
for (lpc = 0; reg_funcs[lpc]; lpc++) {
const struct FuncDef *basic_funcs = NULL;
const struct FuncDefAgg *agg_funcs = NULL;
int i;
reg_funcs[lpc](&basic_funcs, &agg_funcs);
for (i = 0; basic_funcs && basic_funcs[i].zName; i++) {
void *pArg = 0;
switch (basic_funcs[i].argType) {
case 1: pArg = db; break;
case 2: pArg = (void *)(-1); break;
}
//sqlite3CreateFunc
/* LMH no error checking */
sqlite3_create_function(db,
basic_funcs[i].zName,
basic_funcs[i].nArg,
basic_funcs[i].eTextRep,
pArg,
basic_funcs[i].xFunc,
0,
0);
}
for (i = 0; agg_funcs && agg_funcs[i].zName; i++) {
void *pArg = 0;
switch (agg_funcs[i].argType) {
case 1: pArg = db; break;
case 2: pArg = (void *)(-1); break;
}
//sqlite3CreateFunc
sqlite3_create_function(db,
agg_funcs[i].zName,
agg_funcs[i].nArg,
SQLITE_UTF8,
pArg,
0,
agg_funcs[i].xStep,
agg_funcs[i].xFinalize);
}
}
return 0;
}
/*
** This is the "automatic extensionn" initializer that runs right after
** the connection to the repository database is opened. Set up the
** database connection to be more useful to the human operator.
*/
static int sqlcmd_autoinit(
sqlite3 *db,
const char **pzErrMsg,
const void *notUsed
){
sqlite3_create_function(db, "content", 1, SQLITE_ANY, 0,
sqlcmd_content, 0, 0);
sqlite3_create_function(db, "compress", 1, SQLITE_ANY, 0,
sqlcmd_compress, 0, 0);
sqlite3_create_function(db, "decompress", 1, SQLITE_ANY, 0,
sqlcmd_decompress, 0, 0);
return SQLITE_OK;
}
SQLITE_EXTENSION_INIT1
extern int sqlite3_extension_init(sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi) {
SQLITE_EXTENSION_INIT2(pApi)
(void)setlocale(LC_ALL, "en_US.UTF-8");
sqlite3_create_function(db, "tan", 1, SQLITE_UTF8,
0, ora_tan, 0, 0);
// -1 means variable number of arguments
sqlite3_create_function(db, "monthname", 1, SQLITE_UTF8,
0, my_monthname, 0, 0);
return 0;
}
/*
** Extension load function.
*/
int testloadext_init(
sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi
){
int nErr = 0;
SQLITE_EXTENSION_INIT2(pApi);
nErr |= sqlite3_create_function(db, "half", 1, SQLITE_ANY, 0, halfFunc, 0, 0);
nErr |= sqlite3_create_function(db, "sqlite3_status", 1, SQLITE_ANY, 0,
statusFunc, 0, 0);
nErr |= sqlite3_create_function(db, "sqlite3_status", 2, SQLITE_ANY, 0,
statusFunc, 0, 0);
return nErr ? SQLITE_ERROR : SQLITE_OK;
}
/*
** Register the built-in LIKE and GLOB functions. The caseSensitive
** parameter determines whether or not the LIKE operator is case
** sensitive. GLOB is always case sensitive.
*/
void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
struct compareInfo *pInfo;
if( caseSensitive ){
pInfo = (struct compareInfo*)&likeInfoAlt;
}else{
pInfo = (struct compareInfo*)&likeInfoNorm;
}
sqlite3_create_function(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
sqlite3_create_function(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
sqlite3_create_function(db, "glob", 2, SQLITE_UTF8,
(struct compareInfo*)&globInfo, likeFunc, 0,0);
setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
setLikeOptFlag(db, "like",
caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
}
int sqlite3_create_function16(
sqlite3 *db,
const void *zFunctionName,
int nArg,
int eTextRep,
void *pUserData,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*)
){
int rc;
char const *zFunc8;
sqlite3_value *pTmp;
if( sqlite3SafetyCheck(db) ){
return SQLITE_MISUSE;
}
pTmp = sqlite3GetTransientValue(db);
sqlite3ValueSetStr(pTmp, -1, zFunctionName, SQLITE_UTF16NATIVE,SQLITE_STATIC);
zFunc8 = sqlite3ValueText(pTmp, SQLITE_UTF8);
if( !zFunc8 ){
return SQLITE_NOMEM;
}
rc = sqlite3_create_function(db, zFunc8, nArg, eTextRep,
pUserData, xFunc, xStep, xFinal);
return rc;
}
/* call-seq: define_aggregator(name, aggregator)
*
* Define an aggregate function named +name+ using the object +aggregator+.
* +aggregator+ must respond to +step+ and +finalize+. +step+ will be called
* with row information and +finalize+ must return the return value for the
* aggregator function.
*/
static VALUE define_aggregator(VALUE self, VALUE name, VALUE aggregator)
{
sqlite3RubyPtr ctx;
int arity, status;
Data_Get_Struct(self, sqlite3Ruby, ctx);
REQUIRE_OPEN_DB(ctx);
arity = sqlite3_obj_method_arity(aggregator, rb_intern("step"));
status = sqlite3_create_function(
ctx->db,
StringValuePtr(name),
arity,
SQLITE_UTF8,
(void *)aggregator,
NULL,
rb_sqlite3_step,
rb_sqlite3_final
);
rb_iv_set(self, "@agregator", aggregator);
CHECK(ctx->db, status);
return self;
}
bool HHVM_METHOD(SQLite3, createfunction,
const String& name,
const Variant& callback,
int64_t argcount /* = -1 */) {
auto *data = Native::data<SQLite3>(this_);
data->validate();
if (name.empty()) {
return false;
}
if (!is_callable(callback)) {
raise_warning("Not a valid callback function %s",
callback.toString().data());
return false;
}
auto udf = std::make_shared<SQLite3::UserDefinedFunc>();
if (sqlite3_create_function(data->m_raw_db, name.data(), argcount,
SQLITE_UTF8, udf.get(), php_sqlite3_callback_func,
nullptr, nullptr) == SQLITE_OK) {
udf->func = callback;
udf->argc = argcount;
data->m_udfs.push_back(udf);
return true;
}
return false;
}
int sqlite3_eval_init(
sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi
){
int rc = SQLITE_OK;
SQLITE_EXTENSION_INIT2(pApi);
(void)pzErrMsg; /* Unused parameter */
rc = sqlite3_create_function(db, "eval", 1, SQLITE_UTF8, 0,
sqlEvalFunc, 0, 0);
if( rc==SQLITE_OK ){
rc = sqlite3_create_function(db, "eval", 2, SQLITE_UTF8, 0,
sqlEvalFunc, 0, 0);
}
return rc;
}
/* call-seq: define_function(name) { |args,...| }
*
* Define a function named +name+ with +args+. The arity of the block
* will be used as the arity for the function defined.
*/
static VALUE define_function(VALUE self, VALUE name)
{
sqlite3RubyPtr ctx;
VALUE block;
int status;
Data_Get_Struct(self, sqlite3Ruby, ctx);
REQUIRE_OPEN_DB(ctx);
block = rb_block_proc();
status = sqlite3_create_function(
ctx->db,
StringValuePtr(name),
rb_proc_arity(block),
SQLITE_UTF8,
(void *)block,
rb_sqlite3_func,
NULL,
NULL
);
CHECK(ctx->db, status);
return self;
}
static int sfuserdata_mtgc(lua_State *l) {
lua_settop(l, 1); //[u]
assert(lua_type(l, -1) == LUA_TUSERDATA);
//clear the function
lua_getuservalue(l, 1); //[ut]
lua_getfield(l, -1, "dbud"); //[utu]
struct dbuserdata *uddb =
(struct dbuserdata *)lua_touserdata(l, 3);
assert(uddb != NULL);
assert(uddb->db != NULL);
lua_pop(l, 1); //[ut]
lua_getfield(l, -1, "name"); //[uts]
sqlite3_create_function(uddb->db, lua_tostring(l, -1),
-1, SQLITE_ANY, NULL, NULL, NULL, NULL);
struct sfuserdata *ud =
(struct sfuserdata *)lua_touserdata(l, 1);
if(ud->funcref != -1) {
luaL_unref(l, LUA_REGISTRYINDEX, ud->funcref);
}
return 0;
}
static void
tracker_fts_register_functions (sqlite3 *db)
{
sqlite3_create_function (db, "tracker_rank", 2, SQLITE_ANY,
NULL, &function_rank,
NULL, NULL);
sqlite3_create_function (db, "tracker_offsets", 2, SQLITE_ANY,
NULL, &function_offsets,
NULL, NULL);
sqlite3_create_function (db, "fts_column_weights", 0, SQLITE_ANY,
NULL, &function_weights,
NULL, NULL);
sqlite3_create_function (db, "fts_property_names", 0, SQLITE_ANY,
NULL, &function_property_names,
NULL, NULL);
}
/* create function if pos is non-negative, aggregate if agg is true */
int create_function_helper(sqlite3 *db, const char *name, int pos, int agg)
{
return sqlite3_create_function(db, name, -1, SQLITE_ANY, (void*)pos,
pos>=0 && !agg ? &xFunc_helper : 0,
pos>=0 && agg ? &xStep_helper : 0,
pos>=0 && agg ? &xFinal_helper : 0);
}
bool PDOSqliteResource::createFunction(const String& name,
const Variant& callback,
int argcount) {
if (!is_callable(callback)) {
raise_warning("function '%s' is not callable", callback.toString().data());
return false;
}
auto udf = req::make_unique<UDF>();
udf->func = callback;
udf->argc = argcount;
udf->name = name.toCppString();
auto stat = sqlite3_create_function(
conn()->m_db,
udf->name.c_str(),
argcount,
SQLITE_UTF8,
static_cast<SQLite3::UserDefinedFunc*>(udf.get()),
php_sqlite3_callback_func,
nullptr,
nullptr
);
if (stat != SQLITE_OK) {
return false;
}
m_udfs.emplace_back(std::move(udf));
return true;
}
bool PDOSqliteConnection::createFunction(const String& name,
const Variant& callback,
int argcount) {
if (!is_callable(callback)) {
raise_warning("function '%s' is not callable", callback.toString().data());
return false;
}
auto udf = std::make_shared<UDF>();
udf->func = callback;
udf->argc = argcount;
udf->name = name.toCppString();
auto stat = sqlite3_create_function(m_db, udf->name.c_str(), argcount,
SQLITE_UTF8, udf.get(),
php_sqlite3_callback_func,
nullptr, nullptr);
if (stat != SQLITE_OK) {
return false;
}
m_udfs.push_back(udf);
return true;
}
void PDOSqliteConnection::clearFunctions() {
for (auto& udf : m_udfs) {
sqlite3_create_function(m_db, udf->name.data(), 0, SQLITE_UTF8,
nullptr, nullptr, nullptr, nullptr);
}
m_udfs.clear();
}
int main(int argc, char **argv)
{
int rc;
sqlite3 *db;
const char* sql;
sqlite3_open("test.db", &db);
sqlite3_create_function( db, "function", -1, SQLITE_UTF8, NULL,
function, NULL, NULL);
/* Turn on SQL logging */
log_sql(db, 1);
/* Call function with one text argument. */
execute(db, "select function(1)");
/* Call function with several arguments of various types. */
execute(db, "select function(1, 2.71828)");
/* Call function with variable arguments, the first argument’s value
** being 'fail'. This will trigger the function to call
** sqlite3_result_error(). */
execute(db, "select function('fail', 1, 2.71828, 'three', X'0004', NULL)");
/* Done */
sqlite3_close(db);
return 0;
}
SEXP
R_registerSQLFunc(SEXP rdb, SEXP r_func, SEXP rname, SEXP rnargs, SEXP userData)
{
sqlite3 *db = GET_SQLITE_DB(rdb);
void *udata = NULL;
SQLiteFunc fun;
int nargs = INTEGER(rnargs)[0];
if(TYPEOF(r_func) == EXTPTRSXP) {
fun = (SQLiteFunc) R_ExternalPtrAddr(r_func);
if(Rf_length(userData))
udata = R_ExternalPtrAddr(userData);
sqlite3_create_function(db, CHAR(STRING_ELT(rname, 0)), nargs, SQLITE_UTF8, udata, fun, NULL, NULL);
} else {
SEXP expr;
if(nargs > -1) {
expr = allocVector(LANGSXP, nargs + 1);
R_PreserveObject(expr);
SETCAR(expr, r_func);
udata = expr;
fun = R_callFunc;
} else {
R_PreserveObject(r_func);
udata = r_func;
fun = R_mkCallFunc;
}
sqlite3_create_function_v2(db, CHAR(STRING_ELT(rname, 0)), nargs, SQLITE_UTF8, udata, fun, NULL, NULL, Rsqlite_Release);
}
return(R_NilValue); // return a ticket to be able to release the fun.
}
static
void* OGRSQLiteRegisterRegExpFunction(
#ifndef HAVE_PCRE
CPL_UNUSED
#endif
sqlite3* hDB)
{
#ifdef HAVE_PCRE
/* For debugging purposes mostly */
if( !CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_REGEXP", "YES")) )
return NULL;
/* Check if we really need to define our own REGEXP function */
int rc = sqlite3_exec(hDB, "SELECT 'a' REGEXP 'a'", NULL, NULL, NULL);
if( rc == SQLITE_OK )
{
CPLDebug("SQLITE", "REGEXP already available");
return NULL;
}
cache_entry *cache = (cache_entry*) CPLCalloc(CACHE_SIZE, sizeof(cache_entry));
sqlite3_create_function(hDB, "REGEXP", 2, SQLITE_UTF8, cache,
OGRSQLiteREGEXPFunction, NULL, NULL);
/* To clear the error flag */
sqlite3_exec(hDB, "SELECT 1", NULL, NULL, NULL);
return cache;
#else // HAVE_PCRE
return NULL;
#endif // HAVE_PCRE
}
/* SQLite invokes this routine once when it loads the extension.
** Create new functions, collating sequences, and virtual table
** modules here. This is usually the only exported symbol in
** the shared library.
*/
int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
SQLITE_EXTENSION_INIT2(pApi)
// rank call
sqlite3_create_function(db, "rank", 3, SQLITE_ANY, 0, &rank, 0, 0);
return 0;
}
static PHP_METHOD(SQLite, sqliteCreateAggregate)
{
struct pdo_sqlite_func *func;
zval *step_callback, *fini_callback;
char *func_name;
size_t func_name_len;
zend_long argc = -1;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(3, 4)
Z_PARAM_STRING(func_name, func_name_len)
Z_PARAM_ZVAL_DEREF(step_callback)
Z_PARAM_ZVAL_DEREF(fini_callback)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(argc)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(step_callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
if (!zend_is_callable(fini_callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
func, NULL, php_sqlite3_func_step_callback, php_sqlite3_func_final_callback);
if (ret == SQLITE_OK) {
func->funcname = estrdup(func_name);
ZVAL_COPY(&func->step, step_callback);
ZVAL_COPY(&func->fini, fini_callback);
func->argc = argc;
func->next = H->funcs;
H->funcs = func;
RETURN_TRUE;
}
efree(func);
RETURN_FALSE;
}
void KVStore::createFunctions()
{
int ret = sqlite3_create_function(mConn.get(), "escapeStr", 1, SQLITE_ANY, 0, &sqliteEscapeStr, 0, 0);
if (ret != SQLITE_OK) {
throw ConfigException("Error during creating functions: " + mConn.getErrorMessage());
}
}
int
pkg_repo_binary_init(struct pkg_repo *repo)
{
int retcode = EPKG_OK;
sqlite3 *sqlite = PRIV_GET(repo);
sqlite3_create_function(sqlite, "file_exists", 2, SQLITE_ANY, NULL,
sqlite_file_exists, NULL, NULL);
retcode = sql_exec(sqlite, "PRAGMA synchronous=default");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(sqlite, "PRAGMA foreign_keys=on");
if (retcode != EPKG_OK)
return (retcode);
pkgdb_sqlcmd_init(sqlite, NULL, NULL);
retcode = pkg_repo_binary_init_prstatements(sqlite);
if (retcode != EPKG_OK)
return (retcode);
repo->priv = sqlite;
return (EPKG_OK);
}
