static int
monet5_drop_user(ptr _mvc, str user)
{
mvc *m = (mvc *) _mvc;
oid rid;
sql_schema *sys;
sql_table *users;
sql_column *users_name;
str err;
Client c = MCgetClient(m->clientid);
err = AUTHremoveUser(c, user);
if (err !=MAL_SUCCEED) {
(void) sql_error(m, 02, "DROP USER: %s", getExceptionMessage(err));
_DELETE(err);
return FALSE;
}
sys = find_sql_schema(m->session->tr, "sys");
users = find_sql_table(sys, "db_user_info");
users_name = find_sql_column(users, "name");
rid = table_funcs.column_find_row(m->session->tr, users_name, user, NULL);
if (!is_oid_nil(rid))
table_funcs.table_delete(m->session->tr, users, rid);
/* FIXME: We have to ignore this inconsistency here, because the
* user was already removed from the system authorisation. Once
* we have warnings, we could issue a warning about this
* (seemingly) inconsistency between system and sql shadow
* administration. */
return TRUE;
}
/*
* Type: boost::exception
*/
void extractExceptionMessage(const boost::exception& x, std::string& parseMessage) {
const std::string message = getExceptionMessage(x);
if (!message.empty()) {
parseMessage += " \"";
parseMessage += message;
parseMessage += "\"";
}
}
static jstring clearException(JNIEnv *env) {
jthrowable ex = env->ExceptionOccurred();
if (nullptr == ex) {
return nullptr;
}
env->ExceptionClear();
jstring msg = getExceptionMessage(env, ex);
env->DeleteLocalRef(ex);
return msg;
}
std::string getCurrentExceptionMessage(bool with_stacktrace, bool check_embedded_stacktrace)
{
std::stringstream stream;
try
{
throw;
}
catch (const Exception & e)
{
stream << getExceptionMessage(e, with_stacktrace, check_embedded_stacktrace) << " (version " << VERSION_STRING << VERSION_OFFICIAL << ")";
}
catch (const Poco::Exception & e)
{
try
{
stream << "Poco::Exception. Code: " << ErrorCodes::POCO_EXCEPTION << ", e.code() = " << e.code()
<< ", e.displayText() = " << e.displayText()
<< " (version " << VERSION_STRING << VERSION_OFFICIAL << ")";
}
catch (...) {}
}
catch (const std::exception & e)
{
try
{
int status = 0;
auto name = demangle(typeid(e).name(), status);
if (status)
name += " (demangling status: " + toString(status) + ")";
stream << "std::exception. Code: " << ErrorCodes::STD_EXCEPTION << ", type: " << name << ", e.what() = " << e.what() << ", version = " << VERSION_STRING << VERSION_OFFICIAL;
}
catch (...) {}
}
catch (...)
{
try
{
int status = 0;
auto name = demangle(abi::__cxa_current_exception_type()->name(), status);
if (status)
name += " (demangling status: " + toString(status) + ")";
stream << "Unknown exception. Code: " << ErrorCodes::UNKNOWN_EXCEPTION << ", type: " << name << " (version " << VERSION_STRING << VERSION_OFFICIAL << ")";
}
catch (...) {}
}
return stream.str();
}
BlockInputStreams StorageSystemReplicationQueue::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
std::map<String, std::map<String, StoragePtr>> replicated_tables;
for (const auto & db : context.getDatabases())
for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
if (dynamic_cast<const StorageReplicatedMergeTree *>(iterator->table().get()))
replicated_tables[db.first][iterator->name()] = iterator->table();
MutableColumnPtr col_database_mut = ColumnString::create();
MutableColumnPtr col_table_mut = ColumnString::create();
for (auto & db : replicated_tables)
{
for (auto & table : db.second)
{
col_database_mut->insert(db.first);
col_table_mut->insert(table.first);
}
}
ColumnPtr col_database_to_filter = std::move(col_database_mut);
ColumnPtr col_table_to_filter = std::move(col_table_mut);
/// Determine what tables are needed by the conditions in the query.
{
Block filtered_block
{
{ col_database_to_filter, std::make_shared<DataTypeString>(), "database" },
{ col_table_to_filter, std::make_shared<DataTypeString>(), "table" },
};
VirtualColumnUtils::filterBlockWithQuery(query_info.query, filtered_block, context);
if (!filtered_block.rows())
return BlockInputStreams();
col_database_to_filter = filtered_block.getByName("database").column;
col_table_to_filter = filtered_block.getByName("table").column;
}
StorageReplicatedMergeTree::LogEntriesData queue;
String replica_name;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i = 0, tables_size = col_database_to_filter->size(); i < tables_size; ++i)
{
String database = (*col_database_to_filter)[i].safeGet<const String &>();
String table = (*col_table_to_filter)[i].safeGet<const String &>();
dynamic_cast<StorageReplicatedMergeTree &>(*replicated_tables[database][table]).getQueue(queue, replica_name);
for (size_t j = 0, queue_size = queue.size(); j < queue_size; ++j)
{
const auto & entry = queue[j];
Array parts_to_merge;
parts_to_merge.reserve(entry.source_parts.size());
for (const auto & name : entry.source_parts)
parts_to_merge.push_back(name);
size_t col_num = 0;
res_columns[col_num++]->insert(database);
res_columns[col_num++]->insert(table);
res_columns[col_num++]->insert(replica_name);
res_columns[col_num++]->insert(UInt64(j));
res_columns[col_num++]->insert(entry.znode_name);
res_columns[col_num++]->insert(entry.typeToString());
res_columns[col_num++]->insert(UInt64(entry.create_time));
res_columns[col_num++]->insert(UInt64(entry.quorum));
res_columns[col_num++]->insert(entry.source_replica);
res_columns[col_num++]->insert(entry.new_part_name);
res_columns[col_num++]->insert(parts_to_merge);
res_columns[col_num++]->insert(UInt64(entry.detach));
res_columns[col_num++]->insert(UInt64(entry.currently_executing));
res_columns[col_num++]->insert(UInt64(entry.num_tries));
res_columns[col_num++]->insert(entry.exception ? getExceptionMessage(entry.exception, false) : "");
res_columns[col_num++]->insert(UInt64(entry.last_attempt_time));
res_columns[col_num++]->insert(UInt64(entry.num_postponed));
res_columns[col_num++]->insert(entry.postpone_reason);
res_columns[col_num++]->insert(UInt64(entry.last_postpone_time));
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
str
SQLengineIntern(Client c, backend *be)
{
str msg = MAL_SUCCEED;
MalStkPtr oldglb = c->glb;
char oldlang = be->language;
mvc *m = be->mvc;
InstrPtr p;
MalBlkPtr mb;
if (oldlang == 'X') { /* return directly from X-commands */
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emod & mod_explain) {
if (be->q && be->q->code)
printFunction(c->fdout, ((Symbol) (be->q->code))->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
printFunction(c->fdout, c->curprg->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
goto cleanup_engine;
}
if (m->emod & mod_dot) {
if (be->q && be->q->code)
showFlowGraph(((Symbol) (be->q->code))->def, 0, "stdout-mapi");
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
showFlowGraph(c->curprg->def, 0, "stdout-mapi");
goto cleanup_engine;
}
#ifdef SQL_SCENARIO_DEBUG
mnstr_printf(GDKout, "#Ready to execute SQL statement\n");
#endif
if (c->curprg->def->stop == 1) {
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emode == m_inplace) {
msg = SQLexecutePrepared(c, be, be->q);
goto cleanup_engine;
}
if (m->emode == m_prepare)
goto cleanup_engine;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = 0;
be->language = 'D';
/*
* The code below is copied from MALengine, which handles execution
* in the context of a user global environment. We have a private
* environment.
*/
if (MALcommentsOnly(c->curprg->def)) {
msg = MAL_SUCCEED;
} else {
msg = (str) runMAL(c, c->curprg->def, 0, 0);
}
cleanup_engine:
if (m->type == Q_SCHEMA)
qc_clean(m->qc);
if (msg) {
enum malexception type = getExceptionType(msg);
if (type == OPTIMIZER) {
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
if ( msg)
GDKfree(msg);
return SQLrecompile(c, be); // retry compilation
} else {
/* don't print exception decoration, just the message */
char *n = NULL;
char *o = msg;
while ((n = strchr(o, '\n')) != NULL) {
*n = '\0';
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
*n++ = '\n';
o = n;
}
if (*o != 0)
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
}
showErrors(c);
m->session->status = -10;
}
mb = c->curprg->def;
if (m->type != Q_SCHEMA && be->q && msg) {
qc_delete(m->qc, be->q);
} else if (m->type != Q_SCHEMA && be->q && mb && varGetProp(mb, getArg(p = getInstrPtr(mb, 0), 0), runonceProp)) {
msg = SQLCacheRemove(c, getFunctionId(p));
qc_delete(be->mvc->qc, be->q);
///* this should invalidate any match */
//be->q->key= -1;
//be->q->paramlen = -1;
///* qc_delete(be->q) */
}
be->q = NULL;
sqlcleanup(be->mvc, (!msg) ? 0 : -1);
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
/*
* Any error encountered during execution should block further processing
* unless auto_commit has been set.
*/
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
return msg;
}