void SqliteDatabaseBackend::setPragmaValue(const Utf8String &pragmaKey, const Utf8String &newPragmaValue)
{
SqliteReadWriteStatement::execute(Utf8StringLiteral("PRAGMA ") + pragmaKey + Utf8StringLiteral("='") + newPragmaValue + Utf8StringLiteral("'"));
Utf8String pragmeValueInDatabase = SqliteReadWriteStatement::toValue<Utf8String>(Utf8StringLiteral("PRAGMA ") + pragmaKey);
checkPragmaValue(pragmeValueInDatabase, newPragmaValue);
}
void CreateTableSqlStatementBuilder::bindColumnDefinitions() const
{
Utf8StringVector columnDefinitionStrings;
foreach (const ColumnDefinition &columnDefinition, columnDefinitions) {
Utf8String columnDefinitionString = columnDefinition.name() + Utf8StringLiteral(" ") + columnDefinition.typeString();
if (columnDefinition.isPrimaryKey())
columnDefinitionString.append(Utf8StringLiteral(" PRIMARY KEY"));
columnDefinitionStrings.append(columnDefinitionString);
}
void CodeCompletionsExtractor::decreasePriorityForQObjectInternals()
{
quint32 priority = currentCodeCompletion_.priority();
if (currentCodeCompletion_.text().startsWith("qt_"))
priority *= 100;
if (currentCodeCompletion_.text() == Utf8StringLiteral("metaObject"))
priority *= 10;
if (currentCodeCompletion_.text() == Utf8StringLiteral("staticMetaObject"))
priority *= 100;
currentCodeCompletion_.setPriority(priority);
}
void CodeCompletionsExtractor::extractMethodCompletionKind()
{
CXCompletionString cxCompletionString = cxCodeCompleteResults->Results[cxCodeCompleteResultIndex].CompletionString;
const uint annotationCount = clang_getCompletionNumAnnotations(cxCompletionString);
for (uint annotationIndex = 0; annotationIndex < annotationCount; ++annotationIndex) {
ClangString annotation = clang_getCompletionAnnotation(cxCompletionString, annotationIndex);
if (annotation == Utf8StringLiteral("qt_signal")) {
currentCodeCompletion_.setCompletionKind(CodeCompletion::SignalCompletionKind);
return;
}
if (annotation == Utf8StringLiteral("qt_slot")) {
currentCodeCompletion_.setCompletionKind(CodeCompletion::SlotCompletionKind);
return;
}
}
currentCodeCompletion_.setCompletionKind(CodeCompletion::FunctionCompletionKind);
}
ClangCodeCompleteResults CodeCompleter::completeWithArrowInsteadOfDot(uint line,
uint column,
uint dotPosition)
{
ClangCodeCompleteResults results;
const bool replaced = unsavedFile().replaceAt(dotPosition,
1,
Utf8StringLiteral("->"));
if (replaced) {
results = completeHelper(line, column + 1);
if (results.hasResults())
neededCorrection_ = CompletionCorrection::DotToArrowCorrection;
filterUnknownContextResults(results, unsavedFile(), line, column+1);
}
return results;
}
ClangCodeCompleteResults CodeCompleter::completeWithArrowInsteadOfDot(uint line, uint column)
{
ClangCodeCompleteResults results;
const SourceLocation location = translationUnit.sourceLocationAtWithoutReparsing(line, column - 1);
const bool replaced = translationUnit.unsavedFile().replaceAt(location.offset(),
1,
Utf8StringLiteral("->"));
if (replaced) {
results = complete(line,
column + 1,
translationUnit.cxUnsavedFiles(),
translationUnit.unsavedFilesCount());
if (results.hasResults())
neededCorrection_ = CompletionCorrection::DotToArrowCorrection;
}
return results;
}
}
void CreateTableSqlStatementBuilder::bindColumnDefinitions() const
{
Utf8StringVector columnDefinitionStrings;
foreach (const ColumnDefinition &columnDefinition, columnDefinitions) {
Utf8String columnDefinitionString = columnDefinition.name() + Utf8StringLiteral(" ") + columnDefinition.typeString();
if (columnDefinition.isPrimaryKey())
columnDefinitionString.append(Utf8StringLiteral(" PRIMARY KEY"));
columnDefinitionStrings.append(columnDefinitionString);
}
sqlStatementBuilder.bind(Utf8StringLiteral("$columnDefinitions"), columnDefinitionStrings);
}
void CreateTableSqlStatementBuilder::bindAll() const
{
sqlStatementBuilder.bind(Utf8StringLiteral("$table"), tableName);
bindColumnDefinitions();
if (useWithoutRowId)
sqlStatementBuilder.bind(Utf8StringLiteral("$withoutRowId"), Utf8StringLiteral(" WITHOUT ROWID"));
else
sqlStatementBuilder.bindEmptyText(Utf8StringLiteral("$withoutRowId"));
}
}
void SqliteDatabaseBackend::cacheTextEncoding()
{
cachedTextEncoding = pragmaToTextEncoding(pragmaValue(Utf8StringLiteral("encoding")));
}
Utf8StringVector SqliteDatabaseBackend::columnNames(const Utf8String &tableName)
{
SqliteReadStatement statement(Utf8StringLiteral("SELECT * FROM ") + tableName);
return statement.columnNames();
}
void SqliteDatabaseBackend::setTextEncoding(TextEncoding textEncoding)
{
setPragmaValue(Utf8StringLiteral("encoding"), textEncodingToPragma(textEncoding));
cacheTextEncoding();
}
JournalMode SqliteDatabaseBackend::journalMode() const
{
return pragmaToJournalMode(pragmaValue(Utf8StringLiteral("journal_mode")));
}
void SqliteDatabaseBackend::setJournalMode(JournalMode journalMode)
{
setPragmaValue(Utf8StringLiteral("journal_mode"), journalModeToPragma(journalMode));
}
SqliteAbstractTransaction::~SqliteAbstractTransaction()
{
if (!isAlreadyCommited)
SqliteWriteStatement::execute(Utf8StringLiteral("ROLLBACK"));
}
CreateTableSqlStatementBuilder::CreateTableSqlStatementBuilder()
: sqlStatementBuilder(Utf8StringLiteral("CREATE TABLE IF NOT EXISTS $table($columnDefinitions)$withoutRowId")),
useWithoutRowId(false)
{
}
throwException("SqliteDatabaseBackend::checkpointFullWalLog: WAL log could not be checkpointed!");
}
int SqliteDatabaseBackend::indexOfPragma(const Utf8String pragma, const Utf8String pragmas[], size_t pragmaCount)
{
for (unsigned int index = 0; index < pragmaCount; index++) {
if (pragma == pragmas[index])
return int(index);
}
return -1;
}
static const Utf8String journalModeStrings[] = {
Utf8StringLiteral("delete"),
Utf8StringLiteral("truncate"),
Utf8StringLiteral("persist"),
Utf8StringLiteral("memory"),
Utf8StringLiteral("wal")
};
const Utf8String &SqliteDatabaseBackend::journalModeToPragma(JournalMode journalMode)
{
return journalModeStrings[int(journalMode)];
}
JournalMode SqliteDatabaseBackend::pragmaToJournalMode(const Utf8String &pragma)
{
int index = indexOfPragma(pragma, journalModeStrings, SIZE_OF_BYTEARRAY_ARRAY(journalModeStrings));
SqliteExclusiveTransaction::SqliteExclusiveTransaction()
{
SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN EXCLUSIVE"));
}
SqliteImmediateTransaction::SqliteImmediateTransaction()
{
SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN IMMEDIATE"));
}
SqliteTransaction::SqliteTransaction()
{
SqliteWriteStatement::execute(Utf8StringLiteral("BEGIN"));
}
void SqliteAbstractTransaction::commit()
{
SqliteWriteStatement::execute(Utf8StringLiteral("COMMIT"));
isAlreadyCommited = true;
}
Utf8String SqliteDatabaseBackend::pragmaValue(const Utf8String &pragma) const
{
return SqliteReadWriteStatement::toValue<Utf8String>(Utf8StringLiteral("PRAGMA ") + pragma);
}
bool isOperator(CXCursorKind cxCursorKind, const Utf8String &name)
{
return cxCursorKind == CXCursor_ConversionFunction
|| (cxCursorKind == CXCursor_CXXMethod
&& name.startsWith(Utf8StringLiteral("operator")));
}
