diff options
Diffstat (limited to 'src/libs/sqlite')
| -rw-r--r-- | src/libs/sqlite/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/libs/sqlite/createtablesqlstatementbuilder.cpp | 308 | ||||
| -rw-r--r-- | src/libs/sqlite/createtablesqlstatementbuilder.h | 323 | ||||
| -rw-r--r-- | src/libs/sqlite/sqlitecolumn.h | 85 | ||||
| -rw-r--r-- | src/libs/sqlite/sqliteglobal.h | 1 | ||||
| -rw-r--r-- | src/libs/sqlite/sqlitetable.h | 40 | ||||
| -rw-r--r-- | src/libs/sqlite/sqlstatementbuilder.cpp | 20 | ||||
| -rw-r--r-- | src/libs/sqlite/sqlstatementbuilder.h | 2 |
8 files changed, 384 insertions, 397 deletions
diff --git a/src/libs/sqlite/CMakeLists.txt b/src/libs/sqlite/CMakeLists.txt index c200933925..3ad2d371e8 100644 --- a/src/libs/sqlite/CMakeLists.txt +++ b/src/libs/sqlite/CMakeLists.txt @@ -14,7 +14,7 @@ add_qtc_library(Sqlite ../3rdparty/sqlite/config.h ../3rdparty/sqlite/sqlite.h constraints.h - createtablesqlstatementbuilder.cpp createtablesqlstatementbuilder.h + createtablesqlstatementbuilder.h lastchangedrowid.h sqlitealgorithms.h sqlitebasestatement.cpp sqlitebasestatement.h diff --git a/src/libs/sqlite/createtablesqlstatementbuilder.cpp b/src/libs/sqlite/createtablesqlstatementbuilder.cpp deleted file mode 100644 index d237d8e8fc..0000000000 --- a/src/libs/sqlite/createtablesqlstatementbuilder.cpp +++ /dev/null @@ -1,308 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of Qt Creator. -** -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -****************************************************************************/ - -#include "createtablesqlstatementbuilder.h" - -namespace Sqlite { - -CreateTableSqlStatementBuilder::CreateTableSqlStatementBuilder() - : m_sqlStatementBuilder("CREATE $temporaryTABLE $ifNotExits$table($columnDefinitions)$withoutRowId") -{ -} - -void CreateTableSqlStatementBuilder::setTableName(Utils::SmallString &&tableName) -{ - m_sqlStatementBuilder.clear(); - - this->m_tableName = std::move(tableName); -} - -void CreateTableSqlStatementBuilder::addColumn(Utils::SmallStringView columnName, - ColumnType columnType, - Constraints &&constraints) -{ - m_sqlStatementBuilder.clear(); - - m_columns.emplace_back(Utils::SmallStringView{}, columnName, columnType, std::move(constraints)); -} - -void CreateTableSqlStatementBuilder::addConstraint(TableConstraint &&constraint) -{ - m_tableConstraints.push_back(std::move(constraint)); -} - -void CreateTableSqlStatementBuilder::setConstraints(TableConstraints constraints) -{ - m_tableConstraints = std::move(constraints); -} - -void CreateTableSqlStatementBuilder::setColumns(SqliteColumns columns) -{ - m_sqlStatementBuilder.clear(); - - m_columns = std::move(columns); -} - -void CreateTableSqlStatementBuilder::setUseWithoutRowId(bool useWithoutRowId) -{ - m_useWithoutRowId = useWithoutRowId; -} - -void CreateTableSqlStatementBuilder::setUseIfNotExists(bool useIfNotExists) -{ - m_useIfNotExits = useIfNotExists; -} - -void CreateTableSqlStatementBuilder::setUseTemporaryTable(bool useTemporaryTable) -{ - m_useTemporaryTable = useTemporaryTable; -} - -void CreateTableSqlStatementBuilder::clear() -{ - m_sqlStatementBuilder.clear(); - m_columns.clear(); - m_tableName.clear(); - m_useWithoutRowId = false; -} - -void CreateTableSqlStatementBuilder::clearColumns() -{ - m_sqlStatementBuilder.clear(); - m_columns.clear(); -} - -Utils::SmallStringView CreateTableSqlStatementBuilder::sqlStatement() const -{ - if (!m_sqlStatementBuilder.isBuild()) - bindAll(); - - return m_sqlStatementBuilder.sqlStatement(); -} - -bool CreateTableSqlStatementBuilder::isValid() const -{ - return m_tableName.hasContent() && !m_columns.empty(); -} - -namespace { -Utils::SmallStringView actionToText(ForeignKeyAction action) -{ - switch (action) { - case ForeignKeyAction::NoAction: - return "NO ACTION"; - case ForeignKeyAction::Restrict: - return "RESTRICT"; - case ForeignKeyAction::SetNull: - return "SET NULL"; - case ForeignKeyAction::SetDefault: - return "SET DEFAULT"; - case ForeignKeyAction::Cascade: - return "CASCADE"; - } - - return ""; -} - -class ContraintsVisiter -{ -public: - ContraintsVisiter(Utils::SmallString &columnDefinitionString) - : columnDefinitionString(columnDefinitionString) - {} - - void operator()(const Unique &) { columnDefinitionString.append(" UNIQUE"); } - - void operator()(const PrimaryKey &primaryKey) - { - columnDefinitionString.append(" PRIMARY KEY"); - if (primaryKey.autoincrement == AutoIncrement::Yes) - columnDefinitionString.append(" AUTOINCREMENT"); - } - - void operator()(const ForeignKey &foreignKey) - { - columnDefinitionString.append(" REFERENCES "); - columnDefinitionString.append(foreignKey.table); - - if (foreignKey.column.hasContent()) { - columnDefinitionString.append("("); - columnDefinitionString.append(foreignKey.column); - columnDefinitionString.append(")"); - } - - if (foreignKey.updateAction != ForeignKeyAction::NoAction) { - columnDefinitionString.append(" ON UPDATE "); - columnDefinitionString.append(actionToText(foreignKey.updateAction)); - } - - if (foreignKey.deleteAction != ForeignKeyAction::NoAction) { - columnDefinitionString.append(" ON DELETE "); - columnDefinitionString.append(actionToText(foreignKey.deleteAction)); - } - - if (foreignKey.enforcement == Enforment::Deferred) - columnDefinitionString.append(" DEFERRABLE INITIALLY DEFERRED"); - } - - void operator()(const NotNull &) { columnDefinitionString.append(" NOT NULL"); } - - void operator()(const Check &check) - { - columnDefinitionString.append(" CHECK ("); - columnDefinitionString.append(check.expression); - columnDefinitionString.append(")"); - } - - void operator()(const DefaultValue &defaultValue) - { - columnDefinitionString.append(" DEFAULT "); - switch (defaultValue.value.type()) { - case Sqlite::ValueType::Integer: - columnDefinitionString.append( - Utils::SmallString::number(defaultValue.value.toInteger())); - break; - case Sqlite::ValueType::Float: - columnDefinitionString.append(Utils::SmallString::number(defaultValue.value.toFloat())); - break; - case Sqlite::ValueType::String: - columnDefinitionString.append("'"); - columnDefinitionString.append(defaultValue.value.toStringView()); - columnDefinitionString.append("'"); - break; - default: - break; - } - } - - void operator()(const DefaultExpression &defaultexpression) - { - columnDefinitionString.append(" DEFAULT ("); - columnDefinitionString.append(defaultexpression.expression); - columnDefinitionString.append(")"); - } - - void operator()(const Collate &collate) - { - columnDefinitionString.append(" COLLATE "); - columnDefinitionString.append(collate.collation); - } - - void operator()(const GeneratedAlways &generatedAlways) - { - columnDefinitionString.append(" GENERATED ALWAYS AS ("); - columnDefinitionString.append(generatedAlways.expression); - columnDefinitionString.append(")"); - - if (generatedAlways.storage == Sqlite::GeneratedAlwaysStorage::Virtual) - columnDefinitionString.append(" VIRTUAL"); - else - columnDefinitionString.append(" STORED"); - } - - Utils::SmallString &columnDefinitionString; -}; - -class TableContraintsVisiter -{ -public: - TableContraintsVisiter(Utils::SmallString &columnDefinitionString) - : columnDefinitionString(columnDefinitionString) - {} - - void operator()(const TablePrimaryKey &primaryKey) - { - columnDefinitionString.append("PRIMARY KEY("); - columnDefinitionString.append(primaryKey.columns.join(", ")); - columnDefinitionString.append(")"); - } - - Utils::SmallString &columnDefinitionString; -}; -} // namespace -void CreateTableSqlStatementBuilder::bindColumnDefinitionsAndTableConstraints() const -{ - Utils::SmallStringVector columnDefinitionStrings; - columnDefinitionStrings.reserve(m_columns.size()); - - for (const Column &column : m_columns) { - auto columnDefinitionString = Utils::SmallString::join( - {column.name, SqlStatementBuilder::columnTypeToString(column.type)}); - - ContraintsVisiter visiter{columnDefinitionString}; - - for (const Constraint &constraint : column.constraints) - Utils::visit(visiter, constraint); - - columnDefinitionStrings.push_back(std::move(columnDefinitionString)); - } - - for (const TableConstraint &constraint : m_tableConstraints) { - Utils::SmallString columnDefinitionString; - - TableContraintsVisiter visiter{columnDefinitionString}; - Utils::visit(visiter, constraint); - - columnDefinitionStrings.push_back(std::move(columnDefinitionString)); - } - - m_sqlStatementBuilder.bind("$columnDefinitions", columnDefinitionStrings); -} - -void CreateTableSqlStatementBuilder::bindAll() const -{ - m_sqlStatementBuilder.bind("$table", m_tableName.clone()); - - bindTemporary(); - bindIfNotExists(); - bindColumnDefinitionsAndTableConstraints(); - bindWithoutRowId(); -} - -void CreateTableSqlStatementBuilder::bindWithoutRowId() const -{ - if (m_useWithoutRowId) - m_sqlStatementBuilder.bind("$withoutRowId", " WITHOUT ROWID"); - else - m_sqlStatementBuilder.bindEmptyText("$withoutRowId"); -} - -void CreateTableSqlStatementBuilder::bindIfNotExists() const -{ - if (m_useIfNotExits) - m_sqlStatementBuilder.bind("$ifNotExits", "IF NOT EXISTS "); - else - m_sqlStatementBuilder.bindEmptyText("$ifNotExits"); -} - -void CreateTableSqlStatementBuilder::bindTemporary() const -{ - if (m_useTemporaryTable) - m_sqlStatementBuilder.bind("$temporary", "TEMPORARY "); - else - m_sqlStatementBuilder.bindEmptyText("$temporary"); -} - -} // namespace Sqlite diff --git a/src/libs/sqlite/createtablesqlstatementbuilder.h b/src/libs/sqlite/createtablesqlstatementbuilder.h index 3e3743e9da..fb53e68a42 100644 --- a/src/libs/sqlite/createtablesqlstatementbuilder.h +++ b/src/libs/sqlite/createtablesqlstatementbuilder.h @@ -29,43 +29,326 @@ #include "sqlstatementbuilder.h" #include "tableconstraints.h" +#include <type_traits> + namespace Sqlite { +template<typename ColumnType> class SQLITE_EXPORT CreateTableSqlStatementBuilder { public: - CreateTableSqlStatementBuilder(); + CreateTableSqlStatementBuilder() + : m_sqlStatementBuilder(templateText()) + {} + + void setTableName(Utils::SmallString &&tableName) + { + m_sqlStatementBuilder.clear(); - void setTableName(Utils::SmallString &&tableName); + this->m_tableName = std::move(tableName); + } void addColumn(Utils::SmallStringView columnName, ColumnType columnType, - Constraints &&constraints = {}); - void addConstraint(TableConstraint &&constraint); - void setConstraints(TableConstraints constraints); - void setColumns(SqliteColumns columns); - void setUseWithoutRowId(bool useWithoutRowId); - void setUseIfNotExists(bool useIfNotExists); - void setUseTemporaryTable(bool useTemporaryTable); + Constraints &&constraints = {}) + { + m_sqlStatementBuilder.clear(); + + m_columns.emplace_back(Utils::SmallStringView{}, columnName, columnType, std::move(constraints)); + } + void addConstraint(TableConstraint &&constraint) + { + m_tableConstraints.push_back(std::move(constraint)); + } + void setConstraints(TableConstraints constraints) + { + m_tableConstraints = std::move(constraints); + } + void setColumns(BasicColumns<ColumnType> columns) + { + m_sqlStatementBuilder.clear(); + + m_columns = std::move(columns); + } + + void setUseWithoutRowId(bool useWithoutRowId) { m_useWithoutRowId = useWithoutRowId; } + + void setUseIfNotExists(bool useIfNotExists) { m_useIfNotExits = useIfNotExists; } + + void setUseTemporaryTable(bool useTemporaryTable) { m_useTemporaryTable = useTemporaryTable; } + + void clear() + { + m_sqlStatementBuilder.clear(); + m_columns.clear(); + m_tableName.clear(); + m_useWithoutRowId = false; + } + + void clearColumns() + { + m_sqlStatementBuilder.clear(); + m_columns.clear(); + } + + Utils::SmallStringView sqlStatement() const + { + if (!m_sqlStatementBuilder.isBuild()) + bindAll(); + + return m_sqlStatementBuilder.sqlStatement(); + } + + bool isValid() const { return m_tableName.hasContent() && !m_columns.empty(); } + +private: + static Utils::SmallStringView templateText() + { + if constexpr (std::is_same_v<ColumnType, ::Sqlite::ColumnType>) { + return "CREATE $temporaryTABLE $ifNotExits$table($columnDefinitions)$withoutRowId"; + } + + return "CREATE $temporaryTABLE $ifNotExits$table($columnDefinitions)$withoutRowId STRICT"; + } + + static Utils::SmallString columnTypeToString(ColumnType columnType) + { + if constexpr (std::is_same_v<ColumnType, ::Sqlite::ColumnType>) { + switch (columnType) { + case ColumnType::Numeric: + return " NUMERIC"; + case ColumnType::Integer: + return " INTEGER"; + case ColumnType::Real: + return " REAL"; + case ColumnType::Text: + return " TEXT"; + case ColumnType::Blob: + return " BLOB"; + case ColumnType::None: + return {}; + } + } else { + switch (columnType) { + case ColumnType::Any: + return " ANY"; + case ColumnType::Int: + return " INT"; + case ColumnType::Integer: + return " INTEGER"; + case ColumnType::Real: + return " REAL"; + case ColumnType::Text: + return " TEXT"; + case ColumnType::Blob: + return " BLOB"; + } + } + + return ""; + } + + static Utils::SmallStringView actionToText(ForeignKeyAction action) + { + switch (action) { + case ForeignKeyAction::NoAction: + return "NO ACTION"; + case ForeignKeyAction::Restrict: + return "RESTRICT"; + case ForeignKeyAction::SetNull: + return "SET NULL"; + case ForeignKeyAction::SetDefault: + return "SET DEFAULT"; + case ForeignKeyAction::Cascade: + return "CASCADE"; + } + + return ""; + } + + class ContraintsVisiter + { + public: + ContraintsVisiter(Utils::SmallString &columnDefinitionString) + : columnDefinitionString(columnDefinitionString) + {} + + void operator()(const Unique &) { columnDefinitionString.append(" UNIQUE"); } + + void operator()(const PrimaryKey &primaryKey) + { + columnDefinitionString.append(" PRIMARY KEY"); + if (primaryKey.autoincrement == AutoIncrement::Yes) + columnDefinitionString.append(" AUTOINCREMENT"); + } + + void operator()(const ForeignKey &foreignKey) + { + columnDefinitionString.append(" REFERENCES "); + columnDefinitionString.append(foreignKey.table); + + if (foreignKey.column.hasContent()) { + columnDefinitionString.append("("); + columnDefinitionString.append(foreignKey.column); + columnDefinitionString.append(")"); + } + + if (foreignKey.updateAction != ForeignKeyAction::NoAction) { + columnDefinitionString.append(" ON UPDATE "); + columnDefinitionString.append(actionToText(foreignKey.updateAction)); + } + + if (foreignKey.deleteAction != ForeignKeyAction::NoAction) { + columnDefinitionString.append(" ON DELETE "); + columnDefinitionString.append(actionToText(foreignKey.deleteAction)); + } + + if (foreignKey.enforcement == Enforment::Deferred) + columnDefinitionString.append(" DEFERRABLE INITIALLY DEFERRED"); + } + + void operator()(const NotNull &) { columnDefinitionString.append(" NOT NULL"); } + + void operator()(const Check &check) + { + columnDefinitionString.append(" CHECK ("); + columnDefinitionString.append(check.expression); + columnDefinitionString.append(")"); + } + + void operator()(const DefaultValue &defaultValue) + { + columnDefinitionString.append(" DEFAULT "); + switch (defaultValue.value.type()) { + case Sqlite::ValueType::Integer: + columnDefinitionString.append( + Utils::SmallString::number(defaultValue.value.toInteger())); + break; + case Sqlite::ValueType::Float: + columnDefinitionString.append(Utils::SmallString::number(defaultValue.value.toFloat())); + break; + case Sqlite::ValueType::String: + columnDefinitionString.append("'"); + columnDefinitionString.append(defaultValue.value.toStringView()); + columnDefinitionString.append("'"); + break; + default: + break; + } + } + + void operator()(const DefaultExpression &defaultexpression) + { + columnDefinitionString.append(" DEFAULT ("); + columnDefinitionString.append(defaultexpression.expression); + columnDefinitionString.append(")"); + } + + void operator()(const Collate &collate) + { + columnDefinitionString.append(" COLLATE "); + columnDefinitionString.append(collate.collation); + } + + void operator()(const GeneratedAlways &generatedAlways) + { + columnDefinitionString.append(" GENERATED ALWAYS AS ("); + columnDefinitionString.append(generatedAlways.expression); + columnDefinitionString.append(")"); + + if (generatedAlways.storage == Sqlite::GeneratedAlwaysStorage::Virtual) + columnDefinitionString.append(" VIRTUAL"); + else + columnDefinitionString.append(" STORED"); + } + + Utils::SmallString &columnDefinitionString; + }; + + class TableContraintsVisiter + { + public: + TableContraintsVisiter(Utils::SmallString &columnDefinitionString) + : columnDefinitionString(columnDefinitionString) + {} + + void operator()(const TablePrimaryKey &primaryKey) + { + columnDefinitionString.append("PRIMARY KEY("); + columnDefinitionString.append(primaryKey.columns.join(", ")); + columnDefinitionString.append(")"); + } + + Utils::SmallString &columnDefinitionString; + }; + + void bindColumnDefinitionsAndTableConstraints() const + { + Utils::SmallStringVector columnDefinitionStrings; + columnDefinitionStrings.reserve(m_columns.size()); + + for (const BasicColumn<ColumnType> &column : m_columns) { + auto columnDefinitionString = Utils::SmallString::join( + {column.name, columnTypeToString(column.type)}); + + ContraintsVisiter visiter{columnDefinitionString}; + + for (const Constraint &constraint : column.constraints) + Utils::visit(visiter, constraint); + + columnDefinitionStrings.push_back(std::move(columnDefinitionString)); + } + + for (const TableConstraint &constraint : m_tableConstraints) { + Utils::SmallString columnDefinitionString; + + TableContraintsVisiter visiter{columnDefinitionString}; + Utils::visit(visiter, constraint); + + columnDefinitionStrings.push_back(std::move(columnDefinitionString)); + } + + m_sqlStatementBuilder.bind("$columnDefinitions", columnDefinitionStrings); + } + + void bindAll() const + { + m_sqlStatementBuilder.bind("$table", m_tableName.clone()); - void clear(); - void clearColumns(); + bindTemporary(); + bindIfNotExists(); + bindColumnDefinitionsAndTableConstraints(); + bindWithoutRowId(); + } - Utils::SmallStringView sqlStatement() const; + void bindWithoutRowId() const + { + if (m_useWithoutRowId) + m_sqlStatementBuilder.bind("$withoutRowId", " WITHOUT ROWID"); + else + m_sqlStatementBuilder.bindEmptyText("$withoutRowId"); + } - bool isValid() const; + void bindIfNotExists() const + { + if (m_useIfNotExits) + m_sqlStatementBuilder.bind("$ifNotExits", "IF NOT EXISTS "); + else + m_sqlStatementBuilder.bindEmptyText("$ifNotExits"); + } -protected: - void bindColumnDefinitionsAndTableConstraints() const; - void bindAll() const; - void bindWithoutRowId() const; - void bindIfNotExists() const; - void bindTemporary() const; + void bindTemporary() const + { + if (m_useTemporaryTable) + m_sqlStatementBuilder.bind("$temporary", "TEMPORARY "); + else + m_sqlStatementBuilder.bindEmptyText("$temporary"); + } private: mutable SqlStatementBuilder m_sqlStatementBuilder; Utils::SmallString m_tableName; - SqliteColumns m_columns; + BasicColumns<ColumnType> m_columns; TableConstraints m_tableConstraints; bool m_useWithoutRowId = false; bool m_useIfNotExits = false; diff --git a/src/libs/sqlite/sqlitecolumn.h b/src/libs/sqlite/sqlitecolumn.h index 35a5e0f25c..ecca180559 100644 --- a/src/libs/sqlite/sqlitecolumn.h +++ b/src/libs/sqlite/sqlitecolumn.h @@ -28,19 +28,20 @@ #include "constraints.h" #include <functional> +#include <type_traits> namespace Sqlite { - -class Column +template<typename ColumnType> +class BasicColumn { public: - Column() = default; + BasicColumn() = default; - Column(Utils::SmallStringView tableName, - Utils::SmallStringView name, - ColumnType type = ColumnType::None, - Constraints &&constraints = {}) + BasicColumn(Utils::SmallStringView tableName, + Utils::SmallStringView name, + ColumnType type = {}, + Constraints &&constraints = {}) : constraints(std::move(constraints)) , name(name) , tableName(tableName) @@ -50,31 +51,46 @@ public: void clear() { name.clear(); - type = ColumnType::Numeric; + type = {}; constraints = {}; } Utils::SmallString typeString() const { - switch (type) { - case ColumnType::None: - return {}; - case ColumnType::Numeric: - return "NUMERIC"; - case ColumnType::Integer: - return "INTEGER"; - case ColumnType::Real: - return "REAL"; - case ColumnType::Text: - return "TEXT"; - case ColumnType::Blob: - return "BLOB"; + if constexpr (std::is_same_v<ColumnType, ::Sqlite::ColumnType>) { + switch (type) { + case ColumnType::None: + return {}; + case ColumnType::Numeric: + return "NUMERIC"; + case ColumnType::Integer: + return "INTEGER"; + case ColumnType::Real: + return "REAL"; + case ColumnType::Text: + return "TEXT"; + case ColumnType::Blob: + return "BLOB"; + } + } else { + switch (type) { + case ColumnType::Any: + return "ANY"; + case ColumnType::Int: + return "INT"; + case ColumnType::Integer: + return "INTEGER"; + case ColumnType::Real: + return "REAL"; + case ColumnType::Text: + return "TEXT"; + case ColumnType::Blob: + return "BLOB"; + } } - - Q_UNREACHABLE(); } - friend bool operator==(const Column &first, const Column &second) + friend bool operator==(const BasicColumn &first, const BasicColumn &second) { return first.name == second.name && first.type == second.type && first.constraints == second.constraints && first.tableName == second.tableName; @@ -84,11 +100,24 @@ public: Constraints constraints; Utils::SmallString name; Utils::SmallString tableName; - ColumnType type = ColumnType::Numeric; + ColumnType type = {}; }; // namespace Sqlite -using SqliteColumns = std::vector<Column>; -using SqliteColumnConstReference = std::reference_wrapper<const Column>; -using SqliteColumnConstReferences = std::vector<SqliteColumnConstReference>; +using Column = BasicColumn<ColumnType>; +using StrictColumn = BasicColumn<StrictColumnType>; + +using Columns = std::vector<Column>; +using StrictColumns = std::vector<StrictColumn>; +using ColumnConstReference = std::reference_wrapper<const Column>; +using StrictColumnConstReference = std::reference_wrapper<const StrictColumn>; +using ColumnConstReferences = std::vector<Column>; +using StrictColumnConstReferences = std::vector<StrictColumn>; + +template<typename ColumnType> +using BasicColumns = std::vector<BasicColumn<ColumnType>>; +template<typename ColumnType> +using BasicColumnConstReference = std::reference_wrapper<const BasicColumn<ColumnType>>; +template<typename ColumnType> +using BasicColumnConstReferences = std::vector<BasicColumn<ColumnType>>; } // namespace Sqlite diff --git a/src/libs/sqlite/sqliteglobal.h b/src/libs/sqlite/sqliteglobal.h index b910a05a81..f8a13e0a97 100644 --- a/src/libs/sqlite/sqliteglobal.h +++ b/src/libs/sqlite/sqliteglobal.h @@ -40,6 +40,7 @@ namespace Sqlite { enum class ColumnType : char { None, Numeric, Integer, Real, Text, Blob }; +enum class StrictColumnType : char { Any, Integer, Int, Real, Text, Blob }; enum class ConstraintType : char { NoConstraint, PrimaryKey, Unique, ForeignKey }; diff --git a/src/libs/sqlite/sqlitetable.h b/src/libs/sqlite/sqlitetable.h index 1c1f686975..d0bb850656 100644 --- a/src/libs/sqlite/sqlitetable.h +++ b/src/libs/sqlite/sqlitetable.h @@ -35,10 +35,15 @@ namespace Sqlite { class Database; -class Table +template<typename ColumnType> +class BasicTable { public: - Table(std::size_t reserve = 10) + using Column = ::Sqlite::BasicColumn<ColumnType>; + using ColumnConstReferences = ::Sqlite::BasicColumnConstReferences<ColumnType>; + using Columns = ::Sqlite::BasicColumns<ColumnType>; + + BasicTable(std::size_t reserve = 10) { m_sqliteColumns.reserve(reserve); m_sqliteIndices.reserve(reserve); @@ -71,9 +76,7 @@ public: m_useTemporaryTable = useTemporaryTable; } - Column &addColumn(Utils::SmallStringView name, - ColumnType type = ColumnType::None, - Constraints &&constraints = {}) + Column &addColumn(Utils::SmallStringView name, ColumnType type = {}, Constraints &&constraints = {}) { m_sqliteColumns.emplace_back(m_tableName, name, type, std::move(constraints)); @@ -81,7 +84,7 @@ public: } Column &addForeignKeyColumn(Utils::SmallStringView name, - const Table &referencedTable, + const BasicTable &referencedTable, ForeignKeyAction foreignKeyupdateAction = {}, ForeignKeyAction foreignKeyDeleteAction = {}, Enforment foreignKeyEnforcement = {}, @@ -123,18 +126,19 @@ public: return m_sqliteColumns.back(); } - void addPrimaryKeyContraint(const SqliteColumnConstReferences &columns) + void addPrimaryKeyContraint(const BasicColumnConstReferences<ColumnType> &columns) { Utils::SmallStringVector columnNames; columnNames.reserve(columns.size()); for (const auto &column : columns) - columnNames.emplace_back(column.get().name); + columnNames.emplace_back(column.name); m_tableConstraints.emplace_back(TablePrimaryKey{std::move(columnNames)}); } - Index &addIndex(const SqliteColumnConstReferences &columns, Utils::SmallStringView condition = {}) + Index &addIndex(const BasicColumnConstReferences<ColumnType> &columns, + Utils::SmallStringView condition = {}) { return m_sqliteIndices.emplace_back(m_tableName, sqliteColumnNames(columns), @@ -142,7 +146,7 @@ public: condition); } - Index &addUniqueIndex(const SqliteColumnConstReferences &columns, + Index &addUniqueIndex(const BasicColumnConstReferences<ColumnType> &columns, Utils::SmallStringView condition = {}) { return m_sqliteIndices.emplace_back(m_tableName, @@ -151,10 +155,7 @@ public: condition); } - const SqliteColumns &columns() const - { - return m_sqliteColumns; - } + const Columns &columns() const { return m_sqliteColumns; } bool isReady() const { @@ -164,7 +165,7 @@ public: template <typename Database> void initialize(Database &database) { - CreateTableSqlStatementBuilder builder; + CreateTableSqlStatementBuilder<ColumnType> builder; builder.setTableName(m_tableName.clone()); builder.setUseWithoutRowId(m_withoutRowId); @@ -186,7 +187,7 @@ public: database.execute(index.sqlStatement()); } - friend bool operator==(const Table &first, const Table &second) + friend bool operator==(const BasicTable &first, const BasicTable &second) { return first.m_tableName == second.m_tableName && first.m_withoutRowId == second.m_withoutRowId @@ -207,7 +208,7 @@ public: } private: - Utils::SmallStringVector sqliteColumnNames(const SqliteColumnConstReferences &columns) + Utils::SmallStringVector sqliteColumnNames(const ColumnConstReferences &columns) { Utils::SmallStringVector columnNames; @@ -219,7 +220,7 @@ private: private: Utils::SmallString m_tableName; - SqliteColumns m_sqliteColumns; + Columns m_sqliteColumns; SqliteIndices m_sqliteIndices; TableConstraints m_tableConstraints; bool m_withoutRowId = false; @@ -228,4 +229,7 @@ private: bool m_isReady = false; }; +using Table = BasicTable<ColumnType>; +using StrictTable = BasicTable<StrictColumnType>; + } // namespace Sqlite diff --git a/src/libs/sqlite/sqlstatementbuilder.cpp b/src/libs/sqlite/sqlstatementbuilder.cpp index 7a6cc1a81a..b72d1d0328 100644 --- a/src/libs/sqlite/sqlstatementbuilder.cpp +++ b/src/libs/sqlite/sqlstatementbuilder.cpp @@ -176,26 +176,6 @@ bool SqlStatementBuilder::isBuild() const return m_sqlStatement.hasContent(); } -Utils::SmallString SqlStatementBuilder::columnTypeToString(ColumnType columnType) -{ - switch (columnType) { - case ColumnType::Numeric: - return " NUMERIC"; - case ColumnType::Integer: - return " INTEGER"; - case ColumnType::Real: - return " REAL"; - case ColumnType::Text: - return " TEXT"; - case ColumnType::Blob: - return " BLOB"; - case ColumnType::None: - return {}; - } - - Q_UNREACHABLE(); -} - void SqlStatementBuilder::generateSqlStatement() const { m_sqlStatement = m_sqlTemplate; diff --git a/src/libs/sqlite/sqlstatementbuilder.h b/src/libs/sqlite/sqlstatementbuilder.h index 670455dc41..d93f8893e3 100644 --- a/src/libs/sqlite/sqlstatementbuilder.h +++ b/src/libs/sqlite/sqlstatementbuilder.h @@ -57,8 +57,6 @@ public: bool isBuild() const; - static Utils::SmallString columnTypeToString(ColumnType columnType); - protected: static Utils::SmallString insertTemplateParameters(const Utils::SmallStringVector &columns); static Utils::SmallString updateTemplateParameters(const Utils::SmallStringVector &columns); |