static ssize_t chm_imp_unload (mphf_t *mphf){ // {{{
chm_imp_t *data = (chm_imp_t *)&mphf->data;
// save .params
chm_imp_param_write(mphf);
if(data->be_g)
backend_destroy(data->be_g);
if( (data->status & WRITEABLE) ){
backend_destroy(data->be_e);
backend_destroy(data->be_v);
}
return 0;
} // }}}
static int lookup_destroy(backend_t *backend){ // {{{
lookup_userdata *userdata = (lookup_userdata *)backend->userdata;
if(userdata->backend_index != NULL)
backend_destroy(userdata->backend_index);
free(userdata);
return 0;
} // }}}
int slap_destroy(void)
{
int rc;
Debug( LDAP_DEBUG_TRACE,
"%s destroy: freeing system resources.\n",
slap_name, 0, 0 );
if ( default_referral ) {
ber_bvarray_free( default_referral );
}
/* clear out any thread-keys for the main thread */
ldap_pvt_thread_pool_context_reset( ldap_pvt_thread_pool_context());
rc = backend_destroy();
slap_sasl_destroy();
/* rootdse destroy goes before entry_destroy()
* because it may use entry_free() */
root_dse_destroy();
entry_destroy();
switch ( slapMode & SLAP_MODE ) {
case SLAP_SERVER_MODE:
case SLAP_TOOL_MODE:
slap_counters_destroy( &slap_counters );
break;
default:
Debug( LDAP_DEBUG_ANY,
"slap_destroy(): undefined mode (%d).\n", slapMode, 0, 0 );
rc = 1;
break;
}
slap_op_destroy();
ldap_pvt_thread_destroy();
/* should destroy the above mutex */
return rc;
}
str
SQLexitClient(Client c)
{
#ifdef _SQL_SCENARIO_DEBUG
mnstr_printf(GDKout, "#SQLexitClient\n");
#endif
if (SQLinitialized == FALSE)
throw(SQL, "SQLexitClient", "Catalogue not available");
if (c->sqlcontext) {
backend *be = NULL;
mvc *m = NULL;
if (c->sqlcontext == NULL)
throw(SQL, "SQLexitClient", "MVC catalogue not available");
be = (backend *) c->sqlcontext;
m = be->mvc;
assert(m->session);
if (m->session->auto_commit && m->session->active) {
if (mvc_status(m) >= 0 && mvc_commit(m, 0, NULL) < 0)
(void) handle_error(m, c->fdout, 0);
}
if (m->session->active) {
RECYCLEdrop(0);
mvc_rollback(m, 0, NULL);
}
res_tables_destroy(m->results);
m->results = NULL;
mvc_destroy(m);
backend_destroy(be);
c->state[MAL_SCENARIO_OPTIMIZE] = NULL;
c->state[MAL_SCENARIO_PARSER] = NULL;
c->sqlcontext = NULL;
}
c->state[MAL_SCENARIO_READER] = NULL;
return MAL_SUCCEED;
}
void fftf_destroy(FFTFInstance *instance) {
check_instance(instance);
backend_destroy(instance);
}
static ssize_t chm_imp_configure (mphf_t *mphf, request_t *fork_req){ // {{{
ssize_t ret;
backend_t *t;
backend_t *be_g = NULL;
backend_t *be_v = NULL;
backend_t *be_e = NULL;
char *backend = NULL;
uintmax_t nelements_min = CAPACITY_MIN_DEFAULT;
uintmax_t nelements_step = CAPACITY_STEP_DEFAULT;
uintmax_t nelements_mul = CAPACITY_MUL_DEFAULT;
uintmax_t bi_value = VALUE_BITS_DEFAULT;
uintmax_t readonly = 0;
chm_imp_t *data = (chm_imp_t *)&mphf->data;
if( (data->status & FILLED) == 0){
hash_data_copy(ret, TYPE_UINTT, nelements_min, mphf->config, HK(nelements_min));
hash_data_copy(ret, TYPE_UINTT, nelements_step, mphf->config, HK(nelements_step));
hash_data_copy(ret, TYPE_UINTT, nelements_mul, mphf->config, HK(nelements_mul));
hash_data_copy(ret, TYPE_UINTT, bi_value, mphf->config, HK(value_bits)); // number of bits per value to store
hash_data_copy(ret, TYPE_UINTT, readonly, mphf->config, HK(readonly)); // run in read-only mode
hash_data_copy(ret, TYPE_STRINGT, backend, mphf->config, HK(backend_g));
if(ret == 0){
be_g = t = backend_acquire(backend);
if(fork_req){
be_g = backend_fork(t, fork_req);
backend_destroy(t);
}
}
hash_data_copy(ret, TYPE_STRINGT, backend, mphf->config, HK(backend_v));
if(ret == 0){
be_v = t = backend_acquire(backend);
if(fork_req){
be_v = backend_fork(t, fork_req);
backend_destroy(t);
}
}
hash_data_copy(ret, TYPE_STRINGT, backend, mphf->config, HK(backend_e));
if(ret == 0){
be_e = t = backend_acquire(backend);
if(fork_req){
be_e = backend_fork(t, fork_req);
backend_destroy(t);
}
}
if(be_g == NULL)
return error("backend chm_imp parameter backend_g invalid");
if(be_v == NULL || be_e == NULL || readonly != 0){
data->status &= ~WRITEABLE;
}else{
data->status |= WRITEABLE;
}
data->be_g = be_g;
data->be_v = be_v;
data->be_e = be_e;
data->nelements_min = nelements_min;
data->nelements_step = nelements_step;
data->nelements_mul = nelements_mul;
data->bi_value = bi_value;
data->bt_value = BITS_TO_BYTES(data->bi_value);
data->status |= FILLED;
}
return 0;
} // }}}
/*
* BEWARE: SQLstatementIntern only commits after all statements found
* in expr are executed, when autocommit mode is enabled.
*
* The tricky part for this statement is to ensure that the SQL statement
* is executed within the client context specified. This leads to context juggling.
*/
str
SQLstatementIntern(Client c, str *expr, str nme, int execute, bit output, res_table **result)
{
int status = 0;
int err = 0;
mvc *o, *m;
int ac, sizevars, topvars;
sql_var *vars;
int oldvtop, oldstop = 1;
buffer *b;
char *n;
stream *buf;
str msg = MAL_SUCCEED;
backend *be, *sql = (backend *) c->sqlcontext;
size_t len = strlen(*expr);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:%s\n", *expr);
#endif
if (!sql) {
msg = SQLinitEnvironment(c, NULL, NULL, NULL);
sql = (backend *) c->sqlcontext;
}
if (msg){
GDKfree(msg);
throw(SQL, "SQLstatement", "Catalogue not available");
}
initSQLreferences();
m = sql->mvc;
ac = m->session->auto_commit;
o = MNEW(mvc);
if (!o)
throw(SQL, "SQLstatement", "Out of memory");
*o = *m;
/* create private allocator */
m->sa = NULL;
SQLtrans(m);
status = m->session->status;
m->type = Q_PARSE;
be = sql;
sql = backend_create(m, c);
sql->output_format = be->output_format;
m->qc = NULL;
m->caching = 0;
m->user_id = m->role_id = USER_MONETDB;
if (result)
m->reply_size = -2; /* do not cleanup, result tables */
/* mimick a client channel on which the query text is received */
b = (buffer *) GDKmalloc(sizeof(buffer));
n = GDKmalloc(len + 1 + 1);
strncpy(n, *expr, len);
n[len] = '\n';
n[len + 1] = 0;
len++;
buffer_init(b, n, len);
buf = buffer_rastream(b, "sqlstatement");
scanner_init(&m->scanner, bstream_create(buf, b->len), NULL);
m->scanner.mode = LINE_N;
bstream_next(m->scanner.rs);
m->params = NULL;
m->argc = 0;
m->session->auto_commit = 0;
if (!m->sa)
m->sa = sa_create();
/*
* System has been prepared to parse it and generate code.
* Scan the complete string for SQL statements, stop at the first error.
*/
c->sqlcontext = sql;
while (msg == MAL_SUCCEED && m->scanner.rs->pos < m->scanner.rs->len) {
sql_rel *r;
stmt *s;
MalStkPtr oldglb = c->glb;
if (!m->sa)
m->sa = sa_create();
m->sym = NULL;
if ((err = sqlparse(m)) ||
/* Only forget old errors on transaction boundaries */
(mvc_status(m) && m->type != Q_TRANS) || !m->sym) {
if (!err)
err = mvc_status(m);
if (*m->errstr)
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
*m->errstr = 0;
sqlcleanup(m, err);
execute = 0;
if (!err)
continue;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/*
* We have dealt with the first parsing step and advanced the input reader
* to the next statement (if any).
* Now is the time to also perform the semantic analysis,
* optimize and produce code.
* We don't search the cache for a previous incarnation yet.
*/
MSinitClientPrg(c, "user", nme);
oldvtop = c->curprg->def->vtop;
oldstop = c->curprg->def->stop;
r = sql_symbol2relation(m, m->sym);
s = sql_relation2stmt(m, r);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:\n");
#endif
scanner_query_processed(&(m->scanner));
if (s == 0 || (err = mvc_status(m))) {
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
handle_error(m, c->fdout, status);
sqlcleanup(m, err);
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/* generate MAL code */
if (backend_callinline(sql, c, s, 1) == 0)
addQueryToCache(c);
else
err = 1;
if (err ||c->curprg->def->errors) {
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
msg = createException(SQL, "SQLparser", "Errors encountered in query");
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#result of sql.eval()\n");
printFunction(c->fdout, c->curprg->def, 0, c->listing);
#endif
if (execute) {
MalBlkPtr mb = c->curprg->def;
if (!output)
sql->out = NULL; /* no output */
msg = runMAL(c, mb, 0, 0);
MSresetInstructions(mb, oldstop);
freeVariables(c, mb, NULL, oldvtop);
}
sqlcleanup(m, 0);
if (!execute) {
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#parse/execute result %d\n", err);
#endif
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
}
if (m->results && result) { /* return all results sets */
*result = m->results;
m->results = NULL;
}
/*
* We are done; a MAL procedure resides in the cache.
*/
endofcompile:
if (execute)
MSresetInstructions(c->curprg->def, 1);
c->sqlcontext = be;
backend_destroy(sql);
GDKfree(n);
GDKfree(b);
bstream_destroy(m->scanner.rs);
if (m->sa)
sa_destroy(m->sa);
m->sa = NULL;
m->sym = NULL;
/* variable stack maybe resized, ie we need to keep the new stack */
status = m->session->status;
sizevars = m->sizevars;
topvars = m->topvars;
vars = m->vars;
*m = *o;
_DELETE(o);
m->sizevars = sizevars;
m->topvars = topvars;
m->vars = vars;
m->session->status = status;
m->session->auto_commit = ac;
return msg;
}
