1173 lines
37 KiB
C++
1173 lines
37 KiB
C++
/**************************************************************************
|
|
**
|
|
** This file is part of Nut project.
|
|
** https://github.com/HamedMasafi/Nut
|
|
**
|
|
** Nut is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU Lesser General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** Nut is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU Lesser General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU Lesser General Public License
|
|
** along with Nut. If not, see <http://www.gnu.org/licenses/>.
|
|
**
|
|
**************************************************************************/
|
|
|
|
#include <QtCore/QDateTime>
|
|
#include <QtCore/QPointF>
|
|
#include <QtCore/QTime>
|
|
#include <QtCore/QUuid>
|
|
#include <QtCore/QVariant>
|
|
#include <QtCore/QDebug>
|
|
|
|
#include "abstractsqlgenerator.h"
|
|
#include "database.h"
|
|
#include "table.h"
|
|
#include "databasemodel.h"
|
|
#include "tablemodel.h"
|
|
#include "sqlserializer.h"
|
|
|
|
NUT_BEGIN_NAMESPACE
|
|
|
|
/*
|
|
* Index:
|
|
* ALTER TABLE `travelLog` ADD INDEX(`driverId`);
|
|
*
|
|
* Foreign key:
|
|
* ALTER TABLE `travelLog`
|
|
* ADD CONSTRAINT `travelLog_ibfk_1`
|
|
* FOREIGN KEY (`driverId`)
|
|
* REFERENCES `account` (`id`)
|
|
* ON DELETE CASCADE
|
|
* ON UPDATE CASCADE;
|
|
*
|
|
* SELECT
|
|
* FROM dbo.GiftTypes
|
|
* INNER JOIN dbo.GiftCards ON dbo.GiftTypes.GiftTypeID = dbo.GiftCards.GiftTypeID
|
|
* INNER JOIN dbo.Entities ON dbo.GiftCards.GiftCardID = dbo.Entities.GiftCardID
|
|
*/
|
|
bool AbstractSqlGenerator::isNumeric(const QMetaType::Type &type)
|
|
{
|
|
return type == QMetaType::SChar
|
|
|| type == QMetaType::Char
|
|
|| type == QMetaType::UChar
|
|
|| type == QMetaType::Short
|
|
|| type == QMetaType::UShort
|
|
|| type == QMetaType::Int
|
|
|| type == QMetaType::UInt
|
|
|| type == QMetaType::Long
|
|
|| type == QMetaType::ULong
|
|
|| type == QMetaType::LongLong
|
|
|| type == QMetaType::ULongLong;
|
|
}
|
|
|
|
AbstractSqlGenerator::AbstractSqlGenerator(Database *parent)
|
|
: QObject(parent)
|
|
{
|
|
if (parent)
|
|
_database = parent;
|
|
|
|
_serializer = new SqlSerializer;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::masterDatabaseName(QString databaseName)
|
|
{
|
|
Q_UNUSED(databaseName)
|
|
return QString();
|
|
}
|
|
|
|
QString AbstractSqlGenerator::createTable(TableModel *table)
|
|
{
|
|
Q_UNUSED(table)
|
|
return QString();
|
|
}
|
|
|
|
QString AbstractSqlGenerator::saveRecord(Table *t, QString tableName)
|
|
{
|
|
Q_ASSERT(!tableName.isEmpty() && !tableName.isNull());
|
|
switch (t->status()) {
|
|
case Table::Added:
|
|
return insertRecord(t, tableName);
|
|
|
|
case Table::Deleted:
|
|
return deleteRecord(t, tableName);
|
|
|
|
case Table::Modified:
|
|
return updateRecord(t, tableName);
|
|
|
|
case Table::NewCreated:
|
|
case Table::FetchedFromDB:
|
|
Q_UNREACHABLE();
|
|
}
|
|
|
|
return QString();
|
|
}
|
|
|
|
QString AbstractSqlGenerator::recordsPhrase(TableModel *table)
|
|
{
|
|
if (!table)
|
|
return QString();
|
|
|
|
QString ret = QString();
|
|
Q_FOREACH (FieldModel *f, table->fields()) {
|
|
if (!ret.isEmpty())
|
|
ret.append(QLatin1String(", "));
|
|
ret.append(QStringLiteral("%1.%2 AS \"%1.%2\"").arg(table->name(), f->name));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::insertBulk(const QString &tableName, const PhraseList &ph, const QList<QVariantList> &vars)
|
|
{
|
|
QString sql;
|
|
Q_FOREACH (QVariantList list, vars) {
|
|
QStringList values;
|
|
Q_FOREACH (QVariant v, list)
|
|
values.append(escapeValue(v));
|
|
|
|
if (!sql.isEmpty())
|
|
sql.append(QLatin1String(", "));
|
|
sql.append(QLatin1String("(") + values.join(QLatin1String(", ")) + QLatin1String(")"));
|
|
}
|
|
sql = QStringLiteral("INSERT INTO %1 (%2) VALUES %3")
|
|
.arg(tableName, createFieldPhrase(ph), sql);
|
|
|
|
removeTableNames(sql);
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::fieldDeclare(FieldModel *field)
|
|
{
|
|
QString type = fieldType(field);
|
|
if (type.isEmpty())
|
|
return type;
|
|
|
|
QString ret = field->name + QStringLiteral(" ") + type;
|
|
if (field->notNull)
|
|
ret.append(QStringLiteral(" NOT NULL"));
|
|
|
|
if (field->isUnique)
|
|
ret.append(QStringLiteral(" UNIQUE"));
|
|
|
|
return ret;
|
|
}
|
|
|
|
QStringList AbstractSqlGenerator::constraints(TableModel *table)
|
|
{
|
|
Q_UNUSED(table)
|
|
return QStringList();
|
|
}
|
|
|
|
QString AbstractSqlGenerator::relationDeclare(const RelationModel *relation)
|
|
{
|
|
return QStringLiteral("FOREIGN KEY (FK_%1) REFERENCES %2(%1)")
|
|
.arg(relation->localColumn, relation->slaveTable->name());
|
|
}
|
|
|
|
QStringList AbstractSqlGenerator::diff(const DatabaseModel &lastModel,
|
|
const DatabaseModel &newModel)
|
|
{
|
|
QStringList ret;
|
|
|
|
DatabaseModel unionModel = lastModel | newModel;
|
|
DatabaseModel::iterator i;
|
|
|
|
for (i = unionModel.begin(); i != unionModel.end(); ++i) {
|
|
TableModel *oldTable = lastModel.tableByName((*i)->name());
|
|
TableModel *newTable = newModel.tableByName((*i)->name());
|
|
QStringList sql = diff(oldTable, newTable);
|
|
if (!sql.isEmpty())
|
|
ret << sql;
|
|
|
|
// QString sqlRel = diffRelation(oldTable, newTable);
|
|
// if (!sqlRel.isEmpty())
|
|
// ret << sqlRel;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::diff(FieldModel *oldField, FieldModel *newField)
|
|
{
|
|
QString sql = QString();
|
|
if (oldField && newField)
|
|
if (*oldField == *newField)
|
|
return sql;
|
|
|
|
if (!newField) {
|
|
sql = QStringLiteral("DROP COLUMN ") + oldField->name;
|
|
} else {
|
|
if (oldField)
|
|
sql = QStringLiteral("MODIFY COLUMN ");
|
|
else
|
|
sql = QStringLiteral("ADD COLUMN ");
|
|
sql.append(fieldDeclare(newField));
|
|
}
|
|
return sql;
|
|
}
|
|
|
|
QStringList AbstractSqlGenerator::diff(TableModel *oldTable, TableModel *newTable)
|
|
{
|
|
if (!newTable && !oldTable)
|
|
return QStringList();
|
|
|
|
if (oldTable && newTable)
|
|
if (*oldTable == *newTable)
|
|
return QStringList();
|
|
|
|
if (!newTable)
|
|
return QStringList() << (QStringLiteral("DROP TABLE ") + oldTable->name());
|
|
|
|
QList<QString> fieldNames;
|
|
QList<QString> relations;
|
|
|
|
if (oldTable) {
|
|
Q_FOREACH (FieldModel *f, oldTable->fields())
|
|
if (!fieldNames.contains(f->name))
|
|
fieldNames.append(f->name);
|
|
Q_FOREACH (RelationModel *r, oldTable->foreignKeys())
|
|
if (!relations.contains(r->localColumn))
|
|
relations.append(r->localColumn);
|
|
}
|
|
|
|
Q_FOREACH (FieldModel *f, newTable->fields())
|
|
if (!fieldNames.contains(f->name))
|
|
fieldNames.append(f->name);
|
|
Q_FOREACH (RelationModel *r, newTable->foreignKeys())
|
|
if (!relations.contains(r->localColumn))
|
|
relations.append(r->localColumn);
|
|
|
|
QStringList columnSql;
|
|
Q_FOREACH (QString fieldName, fieldNames) {
|
|
FieldModel *newField = newTable->field(fieldName);
|
|
if (oldTable) {
|
|
FieldModel *oldField = oldTable->field(fieldName);
|
|
|
|
QString buffer = diff(oldField, newField);
|
|
if (!buffer.isEmpty())
|
|
columnSql << buffer;
|
|
} else {
|
|
QString declare = fieldDeclare(newField);
|
|
if (declare.isEmpty())
|
|
return QStringList() << declare;
|
|
columnSql << declare;
|
|
}
|
|
}
|
|
// Q_FOREACH (QString fieldName, relations) {
|
|
// RelationModel *newRelation = newTable->foregionKeyByField(fieldName);
|
|
// if (oldTable) {
|
|
// RelationModel *oldRelation = oldTable->foregionKeyByField(fieldName);
|
|
|
|
// QString buffer = diff(oldRelation, newRelation);
|
|
// if (!buffer.isNull())
|
|
// columnSql << buffer;
|
|
// } else {
|
|
// columnSql << relationDeclare(newRelation);
|
|
// }
|
|
// }
|
|
QString sql;
|
|
if (oldTable) {
|
|
sql = QStringLiteral("ALTER TABLE %1 \n%2")
|
|
.arg(newTable->name(), columnSql.join(QStringLiteral(",\n")));
|
|
} else {
|
|
if (!newTable->primaryKey().isNull()) {
|
|
QString pkCon = primaryKeyConstraint(newTable);
|
|
if (!pkCon.isEmpty())
|
|
columnSql << pkCon;
|
|
columnSql << constraints(newTable);
|
|
}
|
|
|
|
sql = QStringLiteral("CREATE TABLE %1 \n(%2)")
|
|
.arg(newTable->name(), columnSql.join(QStringLiteral(",\n")));
|
|
|
|
}
|
|
return QStringList() << sql;
|
|
}
|
|
|
|
QStringList AbstractSqlGenerator::diffRelation(TableModel *oldTable, TableModel *newTable)
|
|
{
|
|
QStringList ret;
|
|
if (!newTable)
|
|
return ret;
|
|
|
|
QList<QString> relations;
|
|
|
|
if (oldTable) {
|
|
Q_FOREACH (RelationModel *r, oldTable->foreignKeys())
|
|
if (!relations.contains(r->localColumn))
|
|
relations.append(r->localColumn);
|
|
}
|
|
|
|
Q_FOREACH (RelationModel *r, newTable->foreignKeys())
|
|
if (!relations.contains(r->localColumn))
|
|
relations.append(r->localColumn);
|
|
|
|
QStringList columnSql;
|
|
Q_FOREACH (QString fieldName, relations) {
|
|
RelationModel *newRelation = newTable->foreignKeyByField(fieldName);
|
|
RelationModel *oldRelation = nullptr;
|
|
if (oldTable)
|
|
oldRelation = oldTable->foreignKeyByField(fieldName);
|
|
|
|
QStringList buffer = diff(oldRelation, newRelation);
|
|
if (!buffer.isEmpty())
|
|
columnSql << buffer.at(0);
|
|
}
|
|
|
|
if (columnSql.count())
|
|
ret.append(QStringLiteral("ALTER TABLE ") + newTable->name()
|
|
+ QStringLiteral("\n")
|
|
+ columnSql.join(QStringLiteral(",\n")));
|
|
|
|
return ret;
|
|
}
|
|
|
|
QStringList AbstractSqlGenerator::diff(RelationModel *oldRel, RelationModel *newRel)
|
|
{
|
|
QStringList ret;
|
|
/*
|
|
CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID)
|
|
REFERENCES Persons(PersonID)
|
|
|
|
ADD CONSTRAINT FK_%1 FOREIGN KEY (%1) REFERENCES %2(%3)
|
|
|
|
return QString("ADD CONSTRAINT FK_%1 FOREIGN KEY (%1) "
|
|
"REFERENCES %2(%3)")
|
|
.arg(newRelation->localColumn)
|
|
.arg(newRelation->masterTable->name())
|
|
.arg(newRelation->foreignColumn);
|
|
*/
|
|
if (!oldRel)
|
|
ret.append(QStringLiteral("ADD CONSTRAINT FK_%1 FOREIGN KEY (%1) "
|
|
"REFERENCES %2(%3)")
|
|
.arg(newRel->localColumn, newRel->masterTable->name(),
|
|
newRel->foreignColumn));
|
|
|
|
if (!newRel)
|
|
ret.append(QStringLiteral("ADD CONSTRAINT FK_%1 FOREIGN KEY (%1) "
|
|
"REFERENCES %2(%3)")
|
|
.arg(oldRel->localColumn, oldRel->masterTable->name(),
|
|
oldRel->foreignColumn));
|
|
|
|
// if (*oldRel == *newRel)
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::join(const QString &mainTable,
|
|
const QList<RelationModel*> &list,
|
|
QStringList *order)
|
|
{
|
|
QString ret = mainTable;
|
|
QList<RelationModel*>::const_iterator i;
|
|
for (i = list.begin(); i != list.end(); ++i) {
|
|
if ((*i)->masterTable->name() == mainTable) {
|
|
ret.append(QStringLiteral(" INNER JOIN %3 ON %1.%2 = %3.%4")
|
|
.arg((*i)->masterTable->name(),
|
|
(*i)->masterTable->primaryKey(),
|
|
(*i)->slaveTable->name(),
|
|
(*i)->localColumn));
|
|
|
|
if (order != Q_NULLPTR)
|
|
order->append((*i)->slaveTable->name() + QStringLiteral(".")
|
|
+ (*i)->slaveTable->primaryKey());
|
|
} else {
|
|
ret.append(QStringLiteral(" INNER JOIN %3 ON %1.%2 = %3.%4")
|
|
.arg(mainTable,
|
|
(*i)->localColumn,
|
|
(*i)->masterTable->name(),
|
|
(*i)->masterTable->primaryKey()));
|
|
|
|
if (order != Q_NULLPTR)
|
|
order->append((*i)->masterTable->name() + QStringLiteral(".")
|
|
+ (*i)->masterTable->primaryKey());
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::join(const QStringList &list, QStringList *order)
|
|
{
|
|
//TODO: reorder list first!
|
|
//TODO: make this ungly code better and bugless :-)
|
|
/*
|
|
* Known issues:
|
|
* Support only near joins, far supports with medium table finding not support yet
|
|
*/
|
|
|
|
if (!list.count())
|
|
return QString();
|
|
|
|
if (list.count() == 1)
|
|
return QStringLiteral("[")
|
|
+ list.first()
|
|
+ QStringLiteral("]");
|
|
|
|
DatabaseModel model = _database->model();
|
|
QStringList clone = list;
|
|
QString mainTable = clone.takeFirst();
|
|
QString ret = QStringLiteral("[")
|
|
+ mainTable
|
|
+ QStringLiteral("]");
|
|
|
|
do {
|
|
if (!clone.count())
|
|
break;
|
|
|
|
QString table = clone.first();// model.tableByClassName(clone.first())->name();
|
|
RelationModel *rel = model.relationByClassNames(mainTable, clone.first());
|
|
if (rel) {
|
|
//mainTable is master of table
|
|
ret.append(QStringLiteral(" INNER JOIN [%1] ON %4.%2 = %1.%3")
|
|
.arg(table, rel->masterTable->primaryKey(),
|
|
rel->localColumn, mainTable));
|
|
|
|
if (order != Q_NULLPTR)
|
|
order->append(mainTable + QStringLiteral(".")
|
|
+ rel->masterTable->primaryKey());
|
|
|
|
} else{
|
|
rel = model.relationByClassNames(clone.first(), mainTable);
|
|
if (rel) {
|
|
// table is master of mainTable
|
|
ret.append(QStringLiteral(" INNER JOIN [%1] ON %4.%2 = %1.%3")
|
|
.arg(table, rel->localColumn,
|
|
rel->masterTable->primaryKey(), mainTable));
|
|
|
|
if (order != Q_NULLPTR)
|
|
order->append(mainTable + QStringLiteral(".")
|
|
+ rel->localColumn);
|
|
|
|
} else {
|
|
// qInfo("Relation for %s and %s not exists",
|
|
// qPrintable(table), qPrintable(mainTable));
|
|
}
|
|
}
|
|
|
|
clone.takeFirst();
|
|
} while (clone.count());
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::insertRecord(Table *t, QString tableName)
|
|
{
|
|
QString sql = QString();
|
|
auto model = _database->model().tableByName(tableName);
|
|
|
|
QString key = model->isPrimaryKeyAutoIncrement() ? model->primaryKey() : QString();
|
|
|
|
QStringList values;
|
|
|
|
QSet<QString> props = t->changedProperties();
|
|
QString changedPropertiesText = QString();
|
|
for (auto &f : props) {
|
|
if (f == key)
|
|
continue;
|
|
|
|
values.append(escapeValue(t->property(f.toLatin1().data())));
|
|
|
|
if (changedPropertiesText != QStringLiteral(""))
|
|
changedPropertiesText.append(QStringLiteral(", "));
|
|
changedPropertiesText.append(f);
|
|
}
|
|
sql = QStringLiteral("INSERT INTO %1 (%2) VALUES (%3)")
|
|
.arg(tableName, changedPropertiesText, values.join(QStringLiteral(", ")));
|
|
|
|
removeTableNames(sql);
|
|
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::updateRecord(Table *t, QString tableName)
|
|
{
|
|
QString sql = QString();
|
|
auto model = _database->model().tableByName(tableName);
|
|
QString key = model->primaryKey();
|
|
QStringList values;
|
|
|
|
for (auto &f : t->changedProperties())
|
|
if (f != key)
|
|
values.append(f + QStringLiteral("=")
|
|
+ escapeValue(t->property(f.toLatin1().data())));
|
|
|
|
sql = QStringLiteral("UPDATE %1 SET %2 WHERE %3=%4")
|
|
.arg(tableName,
|
|
values.join(QStringLiteral(", ")),
|
|
key,
|
|
t->property(key.toUtf8().data()).toString());
|
|
|
|
removeTableNames(sql);
|
|
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::deleteRecord(Table *t, QString tableName)
|
|
{
|
|
auto model = _database->model().tableByName(tableName);
|
|
QString key = model->primaryKey();
|
|
QString sql = QStringLiteral("DELETE FROM %1 WHERE %2='%3'")
|
|
.arg(tableName, key, t->property(key.toUtf8().data()).toString());
|
|
replaceTableNames(sql);
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::agregateText(const AgregateType &t,
|
|
const QString &arg) const
|
|
{
|
|
switch (t) {
|
|
case Min:
|
|
return QStringLiteral("MIN(") + arg + QStringLiteral(")");
|
|
|
|
case Max:
|
|
return QStringLiteral("MAX(") + arg + QStringLiteral(")");
|
|
|
|
case Average:
|
|
return QStringLiteral("AVG(") + arg + QStringLiteral(")");
|
|
|
|
case Count:
|
|
return QStringLiteral("COUNT(") + arg + QStringLiteral(")");
|
|
|
|
case Sum:
|
|
return QStringLiteral("SUM(") + arg + QStringLiteral(")");
|
|
|
|
case SingleField:
|
|
return arg;
|
|
}
|
|
return QString(); // never reach
|
|
}
|
|
|
|
QString AbstractSqlGenerator::fromTableText(const QString &tableName,
|
|
QString &joinClassName,
|
|
QString &orderBy) const
|
|
{
|
|
QString tableNameText = tableName;
|
|
if (!joinClassName.isNull()) {
|
|
QString joinTableName = _database->tableName(joinClassName);
|
|
RelationModel *rel
|
|
= _database->model().relationByTableNames(tableName, joinTableName);
|
|
if (rel) {
|
|
QString pk = _database->model().tableByName(tableName)->primaryKey();
|
|
tableNameText = QStringLiteral("%1 INNER JOIN %2 ON (%1.%3 = %2.%4)")
|
|
.arg(tableName, joinTableName,
|
|
pk, rel->localColumn);
|
|
orderBy = tableName + QStringLiteral(".") + pk;
|
|
} else {
|
|
qWarning("Relation between table %s and class %s (%s) not exists!",
|
|
qPrintable(tableName),
|
|
qPrintable(joinClassName),
|
|
qPrintable(joinTableName.isNull() ? QStringLiteral("NULL") : joinTableName));
|
|
joinClassName = QString();
|
|
}
|
|
}
|
|
|
|
return tableNameText;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::deleteRecords(const QString &tableName, const QString &where)
|
|
{
|
|
QString sql = QStringLiteral("DELETE FROM ") + tableName;
|
|
|
|
if (!where.isEmpty())
|
|
sql.append(QStringLiteral(" WHERE ") + where);
|
|
|
|
replaceTableNames(sql);
|
|
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::selectCommand(const QString &tableName,
|
|
const PhraseList &fields,
|
|
const ConditionalPhrase &where,
|
|
const PhraseList &order,
|
|
const QList<RelationModel*> &joins,
|
|
const int skip,
|
|
const int take)
|
|
{
|
|
Q_UNUSED(skip)
|
|
Q_UNUSED(take)
|
|
QString selectText;
|
|
|
|
if (fields.data.count() == 0) {
|
|
QSet<TableModel*> tables;
|
|
tables.insert(_database->model().tableByName(tableName));
|
|
Q_FOREACH (RelationModel *rel, joins)
|
|
tables << rel->masterTable << rel->slaveTable;
|
|
|
|
selectText = QString();
|
|
Q_FOREACH (TableModel *t, tables) {
|
|
if (!selectText.isEmpty())
|
|
selectText.append(QStringLiteral(", "));
|
|
selectText.append(recordsPhrase(t));
|
|
}
|
|
} else {
|
|
selectText = createFieldPhrase(fields);
|
|
}
|
|
|
|
QStringList joinedOrders;
|
|
QString orderText = createOrderPhrase(order);
|
|
QString whereText = createConditionalPhrase(where.data);
|
|
QString fromText = join(tableName, joins, &joinedOrders);
|
|
|
|
QString sql = QStringLiteral("SELECT ") + selectText
|
|
+ QStringLiteral(" FROM ") + fromText;
|
|
|
|
if (!whereText.isEmpty())
|
|
sql.append(QStringLiteral(" WHERE ") + whereText);
|
|
|
|
if (!orderText.isEmpty())
|
|
sql.append(QStringLiteral(" ORDER BY ") + orderText);
|
|
|
|
// for (int i = 0; i < _database->model().count(); i++)
|
|
// sql = sql.replace(_database->model().at(i)->className() + ".",
|
|
// _database->model().at(i)->name() + ".");
|
|
|
|
appendSkipTake(sql, skip, take);
|
|
replaceTableNames(sql);
|
|
|
|
return sql + QStringLiteral(" ");
|
|
}
|
|
|
|
QString AbstractSqlGenerator::selectCommand(const QString &tableName,
|
|
const AbstractSqlGenerator::AgregateType &t,
|
|
const QString &agregateArg,
|
|
const ConditionalPhrase &where,
|
|
const QList<RelationModel *> &joins,
|
|
const int skip,
|
|
const int take)
|
|
{
|
|
QStringList joinedOrders;
|
|
QString selectText = agregateText(t, agregateArg);
|
|
QString whereText = createConditionalPhrase(where.data);
|
|
QString fromText = join(tableName, joins, &joinedOrders);
|
|
|
|
QString sql = QStringLiteral("SELECT ") + selectText
|
|
+ QStringLiteral(" FROM ") + fromText;
|
|
|
|
if (!whereText.isEmpty())
|
|
sql.append(QStringLiteral(" WHERE ") + whereText);
|
|
|
|
for (int i = 0; i < _database->model().count(); i++)
|
|
sql = sql.replace(_database->model().at(i)->className() + QStringLiteral("."),
|
|
_database->model().at(i)->name() + QStringLiteral("."));
|
|
|
|
appendSkipTake(sql, skip, take);
|
|
replaceTableNames(sql);
|
|
|
|
return sql + QStringLiteral(" ");
|
|
}
|
|
|
|
QString AbstractSqlGenerator::deleteCommand(const QString &tableName,
|
|
const ConditionalPhrase &where)
|
|
{
|
|
QString command = QStringLiteral("DELETE FROM ") + tableName;
|
|
QString whereText = createConditionalPhrase(where.data);
|
|
|
|
if (!whereText.isEmpty())
|
|
command.append(QStringLiteral(" WHERE ") + whereText);
|
|
|
|
for (int i = 0; i < _database->model().count(); i++)
|
|
command = command.replace(_database->model().at(i)->className() + QStringLiteral("."),
|
|
_database->model().at(i)->name() + QStringLiteral("."));
|
|
|
|
replaceTableNames(command);
|
|
|
|
return command;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::updateCommand(const QString &tableName,
|
|
const AssignmentPhraseList &assigments,
|
|
const ConditionalPhrase &where)
|
|
{
|
|
QString assigmentTexts = QString();
|
|
Q_FOREACH (PhraseData *d, assigments.data) {
|
|
if (assigmentTexts != QStringLiteral(""))
|
|
assigmentTexts.append(QStringLiteral(", "));
|
|
|
|
assigmentTexts.append(createConditionalPhrase(d));
|
|
}
|
|
QString whereText = createConditionalPhrase(where.data);
|
|
|
|
QString sql = QStringLiteral("UPDATE ") + tableName
|
|
+ QStringLiteral(" SET ") + assigmentTexts;
|
|
|
|
if (!whereText.isEmpty())
|
|
sql.append(QStringLiteral(" WHERE ") + whereText);
|
|
|
|
for (int i = 0; i < _database->model().count(); i++)
|
|
sql = sql.replace(_database->model().at(i)->className() + QStringLiteral("."),
|
|
_database->model().at(i)->name() + QStringLiteral("."));
|
|
|
|
removeTableNames(sql);
|
|
|
|
return sql;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::insertCommand(const QString &tableName, const AssignmentPhraseList &assigments)
|
|
{
|
|
|
|
QString fieldNames;
|
|
QString values;
|
|
Q_FOREACH (PhraseData *d, assigments.data) {
|
|
if (!fieldNames.isEmpty())
|
|
fieldNames.append(QStringLiteral(", "));
|
|
|
|
if (!values.isEmpty())
|
|
values.append(QStringLiteral(", "));
|
|
|
|
fieldNames.append(QString::fromUtf8(d->left->fieldName));
|
|
values.append(escapeValue(d->operand));
|
|
}
|
|
return QStringLiteral("INSERT INTO %1 (%2) VALUES (%3);")
|
|
.arg(tableName, fieldNames, values);
|
|
}
|
|
|
|
//QString SqlGeneratorBase::selectCommand(SqlGeneratorBase::AgregateType t,
|
|
// QString agregateArg,
|
|
// QString tableName,
|
|
// QList<WherePhrase> &wheres,
|
|
// QList<WherePhrase> &orders,
|
|
// QList<RelationModel*> joins,
|
|
// int skip, int take)
|
|
//{
|
|
// Q_UNUSED(take)
|
|
// Q_UNUSED(skip)
|
|
|
|
// QStringList joinedOrders;
|
|
// QString select = agregateText(t, agregateArg);
|
|
|
|
// //TODO: temporatory disabled
|
|
// if (t == SelectAll) {
|
|
// QSet<TableModel*> tables;
|
|
// tables.insert(_database->model().tableByName(tableName));
|
|
// Q_FOREACH (RelationModel *rel, joins)
|
|
// tables << rel->masterTable << rel->slaveTable;
|
|
|
|
// select = "";
|
|
// Q_FOREACH (TableModel *t, tables) {
|
|
// if (!select.isEmpty())
|
|
// select.append(", ");
|
|
// select.append(recordsPhrase(t));
|
|
// }
|
|
// }
|
|
// QString from = join(tableName, joins, &joinedOrders);
|
|
// QString where = createWhere(wheres);
|
|
// QString orderText = joinedOrders.join(", ");
|
|
|
|
// Q_FOREACH (WherePhrase p, orders) {
|
|
// if (orderText != "")
|
|
// orderText.append(", ");
|
|
// orderText.append(phraseOrder(p.data()));
|
|
// }
|
|
|
|
// QString sql = "SELECT " + select + " FROM " + from;
|
|
|
|
// if (where != "")
|
|
// sql.append(" WHERE " + where);
|
|
|
|
// if (orderText != "")
|
|
// sql.append(" ORDER BY " + orderText);
|
|
|
|
// for (int i = 0; i < _database->model().count(); i++)
|
|
// sql = sql.replace(_database->model().at(i)->className() + ".",
|
|
// _database->model().at(i)->name() + ".");
|
|
|
|
// replaceTableNames(sql);
|
|
|
|
// return sql + " ";
|
|
//}
|
|
|
|
//QString SqlGeneratorBase::createWhere(QList<WherePhrase> &wheres)
|
|
//{
|
|
// QString whereText = "";
|
|
|
|
// Q_FOREACH (WherePhrase w, wheres) {
|
|
// if (whereText != "")
|
|
// whereText.append(" AND ");
|
|
|
|
// whereText.append(phrase(w.data()));
|
|
// }
|
|
|
|
// return whereText;
|
|
//}
|
|
|
|
void AbstractSqlGenerator::replaceTableNames(QString &command)
|
|
{
|
|
Q_FOREACH (TableModel *m, _database->model())
|
|
command = command
|
|
.replace(QStringLiteral("[") + m->className()
|
|
+ QStringLiteral("]"), m->name());
|
|
}
|
|
|
|
void AbstractSqlGenerator::removeTableNames(QString &command)
|
|
{
|
|
Q_FOREACH (TableModel *m, _database->model())
|
|
command = command.replace(QStringLiteral("[")
|
|
+ m->className()
|
|
+ QStringLiteral("]."), QStringLiteral(""));
|
|
}
|
|
|
|
QString AbstractSqlGenerator::dateTimePartName(const PhraseData::Condition &op) const
|
|
{
|
|
switch (op) {
|
|
case PhraseData::DatePartYear:
|
|
case PhraseData::AddYears:
|
|
case PhraseData::AddYearsDateTime:
|
|
return QStringLiteral("YEAR");
|
|
case PhraseData::DatePartMonth:
|
|
case PhraseData::AddMonths:
|
|
case PhraseData::AddMonthsDateTime:
|
|
return QStringLiteral("MONTH");
|
|
case PhraseData::DatePartDay:
|
|
case PhraseData::AddDays:
|
|
case PhraseData::AddDaysDateTime:
|
|
return QStringLiteral("DAY");
|
|
case PhraseData::DatePartHour:
|
|
case PhraseData::AddHours:
|
|
case PhraseData::AddHoursDateTime:
|
|
return QStringLiteral("HOUR");
|
|
case PhraseData::DatePartMinute:
|
|
case PhraseData::AddMinutes:
|
|
case PhraseData::AddMinutesDateTime:
|
|
return QStringLiteral("MINUTE");
|
|
case PhraseData::DatePartSecond:
|
|
case PhraseData::AddSeconds:
|
|
case PhraseData::AddSecondsDateTime:
|
|
return QStringLiteral("SECOND");
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
//QString SqlGeneratorBase::deleteCommand(QList<WherePhrase> &wheres,
|
|
// QString tableName)
|
|
//{
|
|
// QString command = "DELETE FROM " + tableName;
|
|
// QString where = createWhere(wheres);
|
|
|
|
// if (where != "")
|
|
// command.append(" WHERE " + where);
|
|
|
|
// for (int i = 0; i < _database->model().count(); i++)
|
|
// command = command.replace(_database->model().at(i)->className() + ".",
|
|
// _database->model().at(i)->name() + ".");
|
|
|
|
// replaceTableNames(command);
|
|
|
|
// return command;
|
|
//}
|
|
|
|
//QString SqlGeneratorBase::updateCommand(WherePhrase &phrase,
|
|
// QList<WherePhrase> &wheres,
|
|
// QString tableName)
|
|
//{
|
|
// QString p = this->phrase(phrase.data());
|
|
// QString where = createWhere(wheres);
|
|
|
|
// QString sql = "UPDATE " + tableName + " SET " + p;
|
|
|
|
// if (where != "")
|
|
// sql.append(" WHERE " + where);
|
|
|
|
// for (int i = 0; i < _database->model().count(); i++)
|
|
// sql = sql.replace(_database->model().at(i)->className() + ".",
|
|
// _database->model().at(i)->name() + ".");
|
|
|
|
// removeTableNames(sql);
|
|
|
|
// return sql;
|
|
//}
|
|
|
|
QString AbstractSqlGenerator::escapeValue(const QVariant &v) const
|
|
{
|
|
if (v.type() == QVariant::String && v.toString().isEmpty())
|
|
return QStringLiteral("''");
|
|
|
|
if (v.type() == QVariant::List) {
|
|
auto list = v.toList();
|
|
QStringList ret;
|
|
Q_FOREACH (QVariant vi, list) {
|
|
ret.append(QStringLiteral("'")
|
|
+ _serializer->serialize(vi)
|
|
+ QStringLiteral("'"));
|
|
}
|
|
return QStringLiteral("(")
|
|
+ ret.join(QStringLiteral(", "))
|
|
+ QStringLiteral(")");
|
|
}
|
|
|
|
QString serialized = _serializer->serialize(v);
|
|
if (serialized.isEmpty()) {
|
|
qWarning("No field escape rule for: %s", v.typeName());
|
|
return QString();
|
|
}
|
|
|
|
|
|
return QStringLiteral("'") + serialized + QStringLiteral("'");
|
|
}
|
|
|
|
QVariant AbstractSqlGenerator::unescapeValue(const QMetaType::Type &type,
|
|
const QVariant &dbValue)
|
|
{
|
|
return _serializer->deserialize(dbValue.toString(), type);
|
|
}
|
|
|
|
QString AbstractSqlGenerator::phrase(const PhraseData *d) const
|
|
{
|
|
QString ret = QString();
|
|
|
|
switch (d->type) {
|
|
case PhraseData::Field:
|
|
ret = d->toString();
|
|
break;
|
|
|
|
case PhraseData::WithVariant:
|
|
ret = phrase(d->left)
|
|
+ QStringLiteral(" ")
|
|
+ operatorString(d->operatorCond)
|
|
+ QStringLiteral(" ")
|
|
+ escapeValue(d->operand);
|
|
break;
|
|
|
|
case PhraseData::WithOther:
|
|
ret = phrase(d->left) + QStringLiteral(" ") + operatorString(d->operatorCond) + QStringLiteral(" ")
|
|
+ phrase(d->right);
|
|
break;
|
|
|
|
case PhraseData::WithoutOperand:
|
|
ret = phrase(d->left) + QStringLiteral(" ") + operatorString(d->operatorCond);
|
|
break;
|
|
}
|
|
|
|
if (d->operatorCond == PhraseData::And || d->operatorCond == PhraseData::Or)
|
|
ret = QStringLiteral("(") + ret + QStringLiteral(")");
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString
|
|
AbstractSqlGenerator::operatorString(const PhraseData::Condition &cond) const
|
|
{
|
|
switch (cond) {
|
|
case PhraseData::Equal:
|
|
return QStringLiteral("=");
|
|
case PhraseData::NotEqual:
|
|
return QStringLiteral("<>");
|
|
case PhraseData::Less:
|
|
return QStringLiteral("<");
|
|
case PhraseData::Greater:
|
|
return QStringLiteral(">");
|
|
case PhraseData::LessEqual:
|
|
return QStringLiteral("<=");
|
|
case PhraseData::GreaterEqual:
|
|
return QStringLiteral(">=");
|
|
case PhraseData::Null:
|
|
return QStringLiteral("IS NULL");
|
|
|
|
case PhraseData::NotNull:
|
|
return QStringLiteral("IS NOT NULL");
|
|
|
|
case PhraseData::In:
|
|
return QStringLiteral("IN");
|
|
|
|
case PhraseData::NotIn:
|
|
return QStringLiteral("NOT IN");
|
|
|
|
case PhraseData::And:
|
|
return QStringLiteral("AND");
|
|
case PhraseData::Or:
|
|
return QStringLiteral("OR");
|
|
|
|
case PhraseData::Like:
|
|
return QStringLiteral("LIKE");
|
|
case PhraseData::NotLike:
|
|
return QStringLiteral("NOT LIKE");
|
|
|
|
case PhraseData::Add:
|
|
return QStringLiteral("+");
|
|
case PhraseData::Minus:
|
|
return QStringLiteral("-");
|
|
case PhraseData::Multiple:
|
|
return QStringLiteral("*");
|
|
case PhraseData::Divide:
|
|
return QStringLiteral("/");
|
|
|
|
// case PhraseData::Set:
|
|
// return QStringLiteral("=");
|
|
|
|
// case PhraseData::Append:
|
|
// return QStringLiteral(",");
|
|
|
|
case PhraseData::Between:
|
|
return QStringLiteral("BETWEEN");
|
|
|
|
case PhraseData::Mod:
|
|
return QStringLiteral("MOD");
|
|
|
|
default:
|
|
qDebug() << "Unsupported" << cond;
|
|
return QStringLiteral("<FAIL cond> %1").arg(cond);
|
|
}
|
|
}
|
|
|
|
void AbstractSqlGenerator::appendSkipTake(QString &sql, int skip, int take)
|
|
{
|
|
Q_UNUSED(sql)
|
|
Q_UNUSED(skip)
|
|
Q_UNUSED(take)
|
|
}
|
|
|
|
QString AbstractSqlGenerator::primaryKeyConstraint(const TableModel *table) const
|
|
{
|
|
return QStringLiteral("CONSTRAINT pk_%1 PRIMARY KEY (%2)")
|
|
.arg(table->name(), table->primaryKey());
|
|
}
|
|
|
|
QString AbstractSqlGenerator::createConditionalPhrase(const PhraseData *d) const
|
|
{
|
|
if (!d)
|
|
return QString();
|
|
|
|
QString ret = QString();
|
|
|
|
PhraseData::Condition op = d->operatorCond;
|
|
//apply not (!)
|
|
if (d->isNot) {
|
|
if (op < 20)
|
|
op = static_cast<PhraseData::Condition>((op + 10) % 20);
|
|
}
|
|
switch (d->type) {
|
|
case PhraseData::Field:
|
|
ret = d->toString();
|
|
break;
|
|
|
|
case PhraseData::WithVariant:
|
|
/* if (op == PhraseData::AddYears)
|
|
ret = QString("DATEADD(year, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else if (op == PhraseData::AddMonths)
|
|
ret = QString("DATEADD(month, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else if (op == PhraseData::AddDays)
|
|
ret = QString("DATEADD(day, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else if (op == PhraseData::AddHours)
|
|
ret = QString("DATEADD(hour, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else if (op == PhraseData::AddMinutes)
|
|
ret = QString("DATEADD(minute, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else if (op == PhraseData::AddSeconds)
|
|
ret = QString("DATEADD(second, %1, %2)")
|
|
.arg(d->operand.toString(), createConditionalPhrase(d->left));
|
|
else */if (op == PhraseData::Between) {
|
|
QVariantList list = d->operand.toList();
|
|
ret = QStringLiteral("%1 BETWEEN %2 AND %3")
|
|
.arg(createConditionalPhrase(d->left), escapeValue(list.at(0)), escapeValue(list.at(1)));
|
|
|
|
} else if (op == PhraseData::DatePartYear)
|
|
ret = QStringLiteral("DATEPART(year, %1)")
|
|
.arg(d->operand.toString());
|
|
else if (op == PhraseData::DatePartMonth)
|
|
ret = QStringLiteral("DATEPART(month, %1)")
|
|
.arg(d->operand.toString());
|
|
else if (op == PhraseData::DatePartDay)
|
|
ret = QStringLiteral("DATEPART(day, %1)")
|
|
.arg(d->operand.toString());
|
|
else if (op == PhraseData::DatePartHour)
|
|
ret = QStringLiteral("DATEPART(hour, %1)")
|
|
.arg(d->operand.toString());
|
|
else if (op == PhraseData::DatePartMinute)
|
|
ret = QStringLiteral("DATEPART(minute, %1)")
|
|
.arg(d->operand.toString());
|
|
else if (op == PhraseData::DatePartMilisecond)
|
|
ret = QStringLiteral("DATEPART(milisecond, %1)")
|
|
.arg(d->operand.toString());
|
|
else
|
|
ret = createConditionalPhrase(d->left) + QStringLiteral(" ")
|
|
+ operatorString(op) + QStringLiteral(" ")
|
|
+ escapeValue(d->operand);
|
|
break;
|
|
|
|
case PhraseData::WithOther:
|
|
ret = createConditionalPhrase(d->left) + QStringLiteral(" ")
|
|
+ operatorString(op) + QStringLiteral(" ")
|
|
+ createConditionalPhrase(d->right);
|
|
break;
|
|
|
|
case PhraseData::WithoutOperand:
|
|
ret = createConditionalPhrase(d->left) + QStringLiteral(" ")
|
|
+ operatorString(op);
|
|
break;
|
|
}
|
|
|
|
if (d->operatorCond == PhraseData::And || d->operatorCond == PhraseData::Or)
|
|
ret = QStringLiteral("(") + ret + QStringLiteral(")");
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::createOrderPhrase(const PhraseList &ph)
|
|
{
|
|
QString ret = QString();
|
|
Q_FOREACH (const PhraseData *d, ph.data) {
|
|
if (!ret.isEmpty())
|
|
ret.append(QStringLiteral(", "));
|
|
ret.append(d->toString());
|
|
if (d->isNot)
|
|
ret.append(QStringLiteral(" DESC"));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString AbstractSqlGenerator::createFieldPhrase(const PhraseList &ph)
|
|
{
|
|
QString ret = QString();
|
|
Q_FOREACH (const PhraseData *d, ph.data) {
|
|
if (!ret.isEmpty())
|
|
ret.append(QStringLiteral(", "));
|
|
ret.append(d->toString());
|
|
if (d->isNot)
|
|
qDebug() << "Operator ! is ignored in fields phrase";
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void AbstractSqlGenerator::createInsertPhrase(const AssignmentPhraseList &ph, QString &fields, QString &values)
|
|
{
|
|
Q_FOREACH (PhraseData *d, ph.data) {
|
|
if (!fields.isEmpty())
|
|
fields.append(QStringLiteral(", "));
|
|
|
|
if (!values.isEmpty())
|
|
values.append(QStringLiteral(", "));
|
|
|
|
switch (d->type) {
|
|
case PhraseData::WithVariant:
|
|
fields.append(d->left->toString());
|
|
values.append(escapeValue(d->operand));
|
|
// ret = createConditionalPhrase(d->left->toString()) + " " + operatorString(d->operatorCond) + " "
|
|
// + escapeValue(d->operand);
|
|
break;
|
|
|
|
case PhraseData::WithOther:
|
|
fields.append(d->left->toString());
|
|
values.append(d->right->toString());
|
|
break;
|
|
|
|
case PhraseData::Field:
|
|
case PhraseData::WithoutOperand:
|
|
qFatal("Invalid insert command");
|
|
}
|
|
}
|
|
}
|
|
|
|
NUT_END_NAMESPACE
|