// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool PostgreSQLDatabase::beginQuery(const char* query) {
if ( !isConnected() || query == NULL ) return false;
if ( _result ) {
SEISCOMP_ERROR("beginQuery: nested queries are not supported");
//SEISCOMP_DEBUG("last successfull query: %s", _lastQuery.c_str());
return false;
}
endQuery();
_result = PQexec(_handle, query);
if ( _result == NULL ) {
SEISCOMP_ERROR("query(\"%s\"): %s", query, PQerrorMessage(_handle));
return false;
}
ExecStatusType stat = PQresultStatus(_result);
if ( stat != PGRES_TUPLES_OK && stat != PGRES_COMMAND_OK ) {
SEISCOMP_ERROR("QUERY/COMMAND failed");
SEISCOMP_ERROR(" %s", query);
SEISCOMP_ERROR(" %s", PQerrorMessage(_handle));
PQclear(_result);
_result = NULL;
return false;
}
_nRows = PQntuples(_result);
_fieldCount = PQnfields(_result);
return true;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
unsigned long PostgreSQLDatabase::lastInsertId(const char* table) {
if ( !beginQuery((std::string("select currval('") + table + "_seq')").c_str()) )
return 0;
char* value = PQgetvalue(_result, 0, 0);
endQuery();
return value?atoi(value):0;
}
void ThrottledTextureUploader::uploadTexture(CCResourceProvider* resourceProvider, Parameters upload)
{
bool isFullUpload = upload.destOffset.isZero() &&
upload.sourceRect.size() == upload.texture->texture()->size();
if (isFullUpload)
beginQuery();
upload.texture->updateRect(resourceProvider, upload.sourceRect, upload.destOffset);
if (isFullUpload)
endQuery();
}
void StateManagerGL::deleteQuery(GLuint query)
{
if (query != 0)
{
for (auto &activeQuery : mQueries)
{
GLuint activeQueryID = activeQuery.second;
if (activeQueryID == query)
{
GLenum type = activeQuery.first;
endQuery(type, query);
}
}
}
}
void MetricBackend_opengl::endQuery(QueryBoundary boundary) {
if (queryInProgress[boundary]) {
// CPU related
if (metrics[METRIC_CPU_DURATION].profiled[boundary])
{
cpuEnd[boundary] = getCurrentTime();
int64_t time = (cpuEnd[boundary] - cpuStart[boundary]) * cpuTimeScale;
data[METRIC_CPU_DURATION][boundary]->addData(boundary, time);
}
if (metrics[METRIC_CPU_VSIZE_DURATION].profiled[boundary])
{
vsizeEnd[boundary] = os::getVsize();
int64_t time = vsizeEnd[boundary] - vsizeStart[boundary];
data[METRIC_CPU_VSIZE_DURATION][boundary]->addData(boundary, time);
}
if (metrics[METRIC_CPU_RSS_DURATION].profiled[boundary])
{
rssEnd[boundary] = os::getRss();
int64_t time = rssEnd[boundary] - rssStart[boundary];
data[METRIC_CPU_RSS_DURATION][boundary]->addData(boundary, time);
}
// GPU related
if (glQueriesNeeded[boundary]) {
std::array<GLuint, QUERY_LIST_END> &query = queries[boundary].back();
if (metrics[METRIC_GPU_DURATION].profiled[boundary] && supportsTimestamp) {
// GL_TIME_ELAPSED cannot be used in nested queries
// so prefer this if timestamps are supported
glQueryCounter(query[QUERY_GPU_DURATION], GL_TIMESTAMP);
}
if (metrics[METRIC_GPU_PIXELS].profiled[boundary]) {
glEndQuery(GL_SAMPLES_PASSED);
}
}
queryInProgress[boundary] = false;
}
// DRAWCALL is a CALL
if (boundary == QUERY_BOUNDARY_DRAWCALL) endQuery(QUERY_BOUNDARY_CALL);
// clear queries after each frame
if (boundary == QUERY_BOUNDARY_FRAME && glQueriesNeededAnyBoundary) {
processQueries();
}
}
void MetricBackend_opengl::pausePass() {
if (queryInProgress[QUERY_BOUNDARY_FRAME]) endQuery(QUERY_BOUNDARY_FRAME);
processQueries();
}
QueryRef QueryParser::doParse() {
StringRef CommandStr;
ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
.Case("", PQK_NoOp)
.Case("help", PQK_Help)
.Case("m", PQK_Match, /*IsCompletion=*/false)
.Case("match", PQK_Match)
.Case("set", PQK_Set)
.Default(PQK_Invalid);
switch (QKind) {
case PQK_NoOp:
return new NoOpQuery;
case PQK_Help:
return endQuery(new HelpQuery);
case PQK_Match: {
if (CompletionPos) {
std::vector<MatcherCompletion> Comps = Parser::completeExpression(
StringRef(Begin, End - Begin), CompletionPos - Begin);
for (std::vector<MatcherCompletion>::iterator I = Comps.begin(),
E = Comps.end();
I != E; ++I) {
Completions.push_back(
LineEditor::Completion(I->TypedText, I->MatcherDecl));
}
return QueryRef();
} else {
Diagnostics Diag;
Optional<DynTypedMatcher> Matcher =
Parser::parseMatcherExpression(StringRef(Begin, End - Begin), &Diag);
if (!Matcher) {
std::string ErrStr;
llvm::raw_string_ostream OS(ErrStr);
Diag.printToStreamFull(OS);
return new InvalidQuery(OS.str());
}
return new MatchQuery(*Matcher);
}
}
case PQK_Set: {
StringRef VarStr;
ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
.Case("output", PQV_Output)
.Case("bind-root", PQV_BindRoot)
.Default(PQV_Invalid);
if (VarStr.empty())
return new InvalidQuery("expected variable name");
if (Var == PQV_Invalid)
return new InvalidQuery("unknown variable: '" + VarStr + "'");
QueryRef Q;
switch (Var) {
case PQV_Output:
Q = parseSetOutputKind();
break;
case PQV_BindRoot:
Q = parseSetBool(&QuerySession::BindRoot);
break;
case PQV_Invalid:
llvm_unreachable("Invalid query kind");
}
return endQuery(Q);
}
case PQK_Invalid:
return new InvalidQuery("unknown command: " + CommandStr);
}
llvm_unreachable("Invalid query kind");
}
QueryRef QueryParser::doParse() {
StringRef CommandStr;
ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
.Case("", PQK_NoOp)
.Case("help", PQK_Help)
.Case("m", PQK_Match, /*IsCompletion=*/false)
.Case("let", PQK_Let)
.Case("match", PQK_Match)
.Case("set", PQK_Set)
.Case("unlet", PQK_Unlet)
.Default(PQK_Invalid);
switch (QKind) {
case PQK_NoOp:
return new NoOpQuery;
case PQK_Help:
return endQuery(new HelpQuery);
case PQK_Let: {
StringRef Name = lexWord();
if (Name.empty())
return new InvalidQuery("expected variable name");
if (CompletionPos)
return completeMatcherExpression();
Diagnostics Diag;
ast_matchers::dynamic::VariantValue Value;
if (!Parser::parseExpression(StringRef(Begin, End - Begin), nullptr,
&QS.NamedValues, &Value, &Diag)) {
return makeInvalidQueryFromDiagnostics(Diag);
}
return new LetQuery(Name, Value);
}
case PQK_Match: {
if (CompletionPos)
return completeMatcherExpression();
Diagnostics Diag;
Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
StringRef(Begin, End - Begin), nullptr, &QS.NamedValues, &Diag);
if (!Matcher) {
return makeInvalidQueryFromDiagnostics(Diag);
}
return new MatchQuery(*Matcher);
}
case PQK_Set: {
StringRef VarStr;
ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
.Case("output", PQV_Output)
.Case("bind-root", PQV_BindRoot)
.Default(PQV_Invalid);
if (VarStr.empty())
return new InvalidQuery("expected variable name");
if (Var == PQV_Invalid)
return new InvalidQuery("unknown variable: '" + VarStr + "'");
QueryRef Q;
switch (Var) {
case PQV_Output:
Q = parseSetOutputKind();
break;
case PQV_BindRoot:
Q = parseSetBool(&QuerySession::BindRoot);
break;
case PQV_Invalid:
llvm_unreachable("Invalid query kind");
}
return endQuery(Q);
}
case PQK_Unlet: {
StringRef Name = lexWord();
if (Name.empty())
return new InvalidQuery("expected variable name");
return endQuery(new LetQuery(Name, VariantValue()));
}
case PQK_Invalid:
return new InvalidQuery("unknown command: " + CommandStr);
}
llvm_unreachable("Invalid query kind");
}
