From 6302c9e852285990256b4483a3470008344c1d82 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Tue, 27 Jun 2023 22:56:22 +0430 Subject: [PATCH 01/33] Add Support for Create Table --- .../SqlQuery/DDL/DbTypes/MySqlDbType.cs | 37 ++++++++++++ .../SqlQuery/DDL/DbTypes/OracleDbType.cs | 41 +++++++++++++ .../SqlQuery/DDL/DbTypes/PostgresqlDbType.cs | 57 +++++++++++++++++++ .../SqlQuery/DDL/DbTypes/SqlServerDbType.cs | 37 ++++++++++++ .../Dtos/CreateTable/TableColumnDefenition.cs | 13 +++++ .../SqlQuery/DDL/Query.CreateTable.cs | 15 +++++ 6 files changed, 200 insertions(+) create mode 100644 QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs create mode 100644 QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs create mode 100644 QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs create mode 100644 QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs create mode 100644 QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs create mode 100644 QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs b/QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs new file mode 100644 index 00000000..bdb91466 --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs @@ -0,0 +1,37 @@ +namespace SqlKata.SqlQuery.DDL.DbTypes +{ + public enum MySqlDbType + { + SmallInt, + TinyInt, + MediumInt, + Int, + BigInt, + + Bit, + + Decimal, + Float, + Double, + + Date, + TimeStamp, + DateTime, + Time, + Year, + + Varchar, + TinyText, + Text, + MediumText, + LongText, + Char, + + Blob, + LongBlob, + MediumBlob, + TinyBlob, + Binary, + VarBinary + } +} diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs b/QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs new file mode 100644 index 00000000..91ca76a2 --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs @@ -0,0 +1,41 @@ +namespace SqlKata.SqlQuery.DDL.DbTypes +{ + public enum OracleDbType + { + BFile = 101, + Blob = 102, + Byte = 103, + Char = 104, + Clob = 105, + Date = 106, + Decimal = 107, + Double = 108, + Long = 109, + LongRaw = 110, + Int16 = 111, + Int32 = 112, + Int64 = 113, + IntervalDS = 114, + IntervalYM = 115, + NClob = 116, + NChar = 117, + NVarchar2 = 119, + Raw = 120, + RefCursor = 121, + Single = 122, + TimeStamp = 123, + TimeStampLTZ = 124, + TimeStampTZ = 125, + Varchar2 = 126, + XmlType = 0x7F, + Array = 0x80, + Object = 129, + Ref = 130, + BinaryDouble = 132, + BinaryFloat = 133, + Boolean = 134, + Json = 135, + ArrayAsJson = 136, + ObjectAsJson = 137 + } +} diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs b/QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs new file mode 100644 index 00000000..68031319 --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs @@ -0,0 +1,57 @@ +namespace SqlKata.SqlQuery.DDL.DbTypes +{ + public enum PostgresqlDbType + { + Smallint, + Integer, + Bigint, + Smallserial, + Serial, + Bigserial, + + Boolean, + + Numeric, + Double_precision, + Real, + + Timestamp_with_time_zone, + Timestamp_without_time_zone, + Date, + Time_with_time_zone, + Time_without_time_zone, + + Character, + Character_varying, + Char, + + Text, + + Uuid, + + + //not supported types + Bytea, + Bit, + Bit_varying, + Interval, + Box, + Cidr, + Circle, + Inet, + Json, + Jsonb, + Line, + Lseg, + Macaddr, + Money, + Path, + Pg_ln, + Point, + Polygon, + Tsquery, + Tsvector, + Txid_snapshot, + Xml + } +} diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs b/QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs new file mode 100644 index 00000000..4e004087 --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs @@ -0,0 +1,37 @@ +namespace SqlKata.SqlQuery.DDL.DbTypes +{ + public enum SqlServerDbType + { + Varchar, + Nvarchar, + Char, + NChar, + Text, + + Bit, + + DateTime, + DateTime2, + SmallDateTime, + + Date, + Time, + + Int, + BigInt, + SmallInt, + TinyInt, + + Decimal, + Float, + Real, + numeric, + money, + + UniqueIdentifier, + Image, + VarBinary, + Binary, + TimeStamp, + } +} diff --git a/QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs b/QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs new file mode 100644 index 00000000..c20cdca5 --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs @@ -0,0 +1,13 @@ +namespace SqlKata.SqlQuery.DDL.Dtos.CreateTable +{ + public class TableColumnDefenition + { + public string ColumnName { get; set; } + public string ColumnDbType { get; set; } + public bool IsNullable { get; set; } + public bool IsPrimaryKey { get; set; } + public bool IsUnique { get; set; } + public bool IsIdentity { get; set; } + public bool IsAutoIncrement { get; set; } + } +} diff --git a/QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs b/QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs new file mode 100644 index 00000000..cac5c41d --- /dev/null +++ b/QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs @@ -0,0 +1,15 @@ +using SqlKata.SqlQuery.DDL.Dtos.CreateTable; +using System.Collections.Generic; + +namespace SqlKata.SqlQuery.DDL +{ + public partial class Query + { + public Query CreateTable(string tableName,IEnumerable columns) + { + + return null; + } + + } +} From c2632d04d204cdbb16a86a357f4aacd162b68ec4 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Tue, 27 Jun 2023 23:01:30 +0430 Subject: [PATCH 02/33] Create Table Query making is started --- .../CreateTable/TableColumnDefenition.cs | 2 +- QueryBuilder/{SqlQuery/DDL => }/DbTypes/MySqlDbType.cs | 2 +- QueryBuilder/{SqlQuery/DDL => }/DbTypes/OracleDbType.cs | 2 +- .../{SqlQuery/DDL => }/DbTypes/PostgresqlDbType.cs | 2 +- .../{SqlQuery/DDL => }/DbTypes/SqlServerDbType.cs | 2 +- QueryBuilder/{SqlQuery/DDL => }/Query.CreateTable.cs | 9 ++++++--- 6 files changed, 11 insertions(+), 8 deletions(-) rename QueryBuilder/{SqlQuery/DDL/Dtos => Contract}/CreateTable/TableColumnDefenition.cs (88%) rename QueryBuilder/{SqlQuery/DDL => }/DbTypes/MySqlDbType.cs (92%) rename QueryBuilder/{SqlQuery/DDL => }/DbTypes/OracleDbType.cs (95%) rename QueryBuilder/{SqlQuery/DDL => }/DbTypes/PostgresqlDbType.cs (95%) rename QueryBuilder/{SqlQuery/DDL => }/DbTypes/SqlServerDbType.cs (92%) rename QueryBuilder/{SqlQuery/DDL => }/Query.CreateTable.cs (50%) diff --git a/QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs similarity index 88% rename from QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs rename to QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs index c20cdca5..e3d8aceb 100644 --- a/QueryBuilder/SqlQuery/DDL/Dtos/CreateTable/TableColumnDefenition.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs @@ -1,4 +1,4 @@ -namespace SqlKata.SqlQuery.DDL.Dtos.CreateTable +namespace SqlKata.Contract.CreateTable { public class TableColumnDefenition { diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs b/QueryBuilder/DbTypes/MySqlDbType.cs similarity index 92% rename from QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs rename to QueryBuilder/DbTypes/MySqlDbType.cs index bdb91466..642d28e2 100644 --- a/QueryBuilder/SqlQuery/DDL/DbTypes/MySqlDbType.cs +++ b/QueryBuilder/DbTypes/MySqlDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.SqlQuery.DDL.DbTypes +namespace SqlKata.DbTypes { public enum MySqlDbType { diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs b/QueryBuilder/DbTypes/OracleDbType.cs similarity index 95% rename from QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs rename to QueryBuilder/DbTypes/OracleDbType.cs index 91ca76a2..8780ed65 100644 --- a/QueryBuilder/SqlQuery/DDL/DbTypes/OracleDbType.cs +++ b/QueryBuilder/DbTypes/OracleDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.SqlQuery.DDL.DbTypes +namespace SqlKata.DbTypes { public enum OracleDbType { diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs b/QueryBuilder/DbTypes/PostgresqlDbType.cs similarity index 95% rename from QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs rename to QueryBuilder/DbTypes/PostgresqlDbType.cs index 68031319..99b6dc9a 100644 --- a/QueryBuilder/SqlQuery/DDL/DbTypes/PostgresqlDbType.cs +++ b/QueryBuilder/DbTypes/PostgresqlDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.SqlQuery.DDL.DbTypes +namespace SqlKata.DbTypes { public enum PostgresqlDbType { diff --git a/QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs b/QueryBuilder/DbTypes/SqlServerDbType.cs similarity index 92% rename from QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs rename to QueryBuilder/DbTypes/SqlServerDbType.cs index 4e004087..384efbd8 100644 --- a/QueryBuilder/SqlQuery/DDL/DbTypes/SqlServerDbType.cs +++ b/QueryBuilder/DbTypes/SqlServerDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.SqlQuery.DDL.DbTypes +namespace SqlKata.DbTypes { public enum SqlServerDbType { diff --git a/QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs similarity index 50% rename from QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs rename to QueryBuilder/Query.CreateTable.cs index cac5c41d..a71fd4f7 100644 --- a/QueryBuilder/SqlQuery/DDL/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -1,13 +1,16 @@ using SqlKata.SqlQuery.DDL.Dtos.CreateTable; using System.Collections.Generic; -namespace SqlKata.SqlQuery.DDL +namespace SqlKata { public partial class Query { - public Query CreateTable(string tableName,IEnumerable columns) + public Query CreateTable(string tableName, IEnumerable columns,bool isTempTable) { - + Method = "CreateTable"; + + + return null; } From 31b7d97c4951a3d032ba4a21ff23505413f527bc Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Tue, 27 Jun 2023 23:21:22 +0430 Subject: [PATCH 03/33] change the type of create table return type and change the type of column type! --- QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs | 2 +- QueryBuilder/Query.CreateTable.cs | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs index e3d8aceb..8d6f3fb6 100644 --- a/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs @@ -3,7 +3,7 @@ namespace SqlKata.Contract.CreateTable public class TableColumnDefenition { public string ColumnName { get; set; } - public string ColumnDbType { get; set; } + public object ColumnDbType { get; set; } public bool IsNullable { get; set; } public bool IsPrimaryKey { get; set; } public bool IsUnique { get; set; } diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index a71fd4f7..fd9f987b 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -1,17 +1,15 @@ -using SqlKata.SqlQuery.DDL.Dtos.CreateTable; +using SqlKata.Contract.CreateTable; using System.Collections.Generic; namespace SqlKata { public partial class Query { - public Query CreateTable(string tableName, IEnumerable columns,bool isTempTable) + public void CreateTable(IEnumerable columns,bool isTempTable) { Method = "CreateTable"; - - return null; } } From 1959d039cdebb45e96305fe468e174f6398ba503 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Tue, 27 Jun 2023 23:48:15 +0430 Subject: [PATCH 04/33] Create Table Class for Query is Added --- QueryBuilder/Clauses/ColumnClause.cs | 25 +++++++++++++++++++ QueryBuilder/Clauses/TableCluase.cs | 16 ++++++++++++ ...enition.cs => TableColumnDefenitionDto.cs} | 2 +- .../Contract/CreateTable/TableType.cs | 8 ++++++ QueryBuilder/Query.CreateTable.cs | 21 +++++++++++++++- 5 files changed, 70 insertions(+), 2 deletions(-) create mode 100644 QueryBuilder/Clauses/TableCluase.cs rename QueryBuilder/Contract/CreateTable/{TableColumnDefenition.cs => TableColumnDefenitionDto.cs} (90%) create mode 100644 QueryBuilder/Contract/CreateTable/TableType.cs diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index dd51a85e..f3339b1f 100644 --- a/QueryBuilder/Clauses/ColumnClause.cs +++ b/QueryBuilder/Clauses/ColumnClause.cs @@ -30,6 +30,31 @@ public override AbstractClause Clone() } } + public class CreateTableColumn : AbstractClause + { + public string ColumnName { get; set; } + public object ColumnDbType { get; set; } + public bool IsNullable { get; set; } + public bool IsPrimaryKey { get; set; } + public bool IsUnique { get; set; } + public bool IsIdentity { get; set; } + public bool IsAutoIncrement { get; set; } + public override AbstractClause Clone() + { + return new CreateTableColumn + { + ColumnDbType= ColumnDbType, + ColumnName= ColumnName, + IsAutoIncrement= IsAutoIncrement, + IsPrimaryKey= IsPrimaryKey, + IsUnique= IsUnique, + IsIdentity= IsIdentity, + }; + } + } + + + /// /// Represents column clause calculated using query. /// diff --git a/QueryBuilder/Clauses/TableCluase.cs b/QueryBuilder/Clauses/TableCluase.cs new file mode 100644 index 00000000..6ba53ed4 --- /dev/null +++ b/QueryBuilder/Clauses/TableCluase.cs @@ -0,0 +1,16 @@ +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Clauses +{ + public class TableCluase : AbstractClause + { + public TableType TableType { get; set; } + public override AbstractClause Clone() + { + return new TableCluase() + { + TableType = TableType, + }; + } + } +} diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs similarity index 90% rename from QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs rename to QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs index 8d6f3fb6..ae797288 100644 --- a/QueryBuilder/Contract/CreateTable/TableColumnDefenition.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs @@ -1,6 +1,6 @@ namespace SqlKata.Contract.CreateTable { - public class TableColumnDefenition + public class TableColumnDefenitionDto { public string ColumnName { get; set; } public object ColumnDbType { get; set; } diff --git a/QueryBuilder/Contract/CreateTable/TableType.cs b/QueryBuilder/Contract/CreateTable/TableType.cs new file mode 100644 index 00000000..7b1207bf --- /dev/null +++ b/QueryBuilder/Contract/CreateTable/TableType.cs @@ -0,0 +1,8 @@ +namespace SqlKata.Contract.CreateTable +{ + public enum TableType + { + Permanent = 0, + Temporary = 1, + } +} diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index fd9f987b..48a4cd8f 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -1,15 +1,34 @@ +using SqlKata.Clauses; using SqlKata.Contract.CreateTable; using System.Collections.Generic; +using System.Linq; namespace SqlKata { public partial class Query { - public void CreateTable(IEnumerable columns,bool isTempTable) + public void CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent) { Method = "CreateTable"; + ClearComponent("TableType").AddComponent("TableType",new TableCluase() + { + TableType = tableType + }); + columns.ToList().ForEach(column => + { + AddComponent("CreateTableColumn",new CreateTableColumn() + { + ColumnName = column.ColumnName, + ColumnDbType = column.ColumnDbType, + IsNullable = column.IsNullable, + IsUnique = column.IsUnique, + IsPrimaryKey = column.IsPrimaryKey, + IsAutoIncrement = column.IsAutoIncrement, + IsIdentity = column.IsIdentity + }); + }); } } From 0c72c030f0165a076bb5d5991104ecfd7b0819f7 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 28 Jun 2023 00:44:32 +0430 Subject: [PATCH 05/33] Adding sql server compiler for create table --- QueryBuilder/Compilers/Compiler.cs | 17 +++++++++++++ QueryBuilder/Compilers/SqlServerCompiler.cs | 23 ++++++++++++++++++ ...utoIncrementOrIdentityExceededException.cs | 24 +++++++++++++++++++ 3 files changed, 64 insertions(+) create mode 100644 QueryBuilder/Exceptions/CreateTableQuery/AutoIncrementOrIdentityExceededException.cs diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index aa15c789..9202f413 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -124,6 +124,10 @@ protected virtual SqlResult CompileRaw(Query query) { ctx = CompileDeleteQuery(query); } + else if (query.Method == "CreateTable") + { + ctx = CompileCreateTable(query); + } else { if (query.Method == "aggregate") @@ -227,6 +231,19 @@ protected virtual SqlResult CompileSelectQuery(Query query) return ctx; } + /// + /// gets create table query. each db has its own implementation + /// + /// + /// + protected virtual SqlResult CompileCreateTable(Query query) + { + var ctx = new SqlResult() + { + Query= query.Clone(), + }; + return ctx; + } protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) { var ctx = new SqlResult(); diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 0202f0f1..228a5c20 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,4 +1,7 @@ +using SqlKata.Clauses; +using SqlKata.Contract.CreateTable; using System.Linq; +using System.Text; namespace SqlKata.Compilers { @@ -186,5 +189,25 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) return ctx; } + + protected override SqlResult CompileCreateTable(Query query) + { + var result = base.CompileCreateTable(query); + var tableName = result.Query.GetOneComponent("from", EngineCode).Table; + var tableType = result.Query.GetOneComponent("TableType").TableType; + if(tableType == TableType.Temporary) + tableName = new StringBuilder("#").Append(tableName).ToString(); + + var queryString = new StringBuilder($"Create Table {tableName} "); + queryString.Append("(\n"); + var createTableColumnCluases = + + + + queryString.Append(")\n"); + result.RawSql = queryString.ToString(); + return result; + } + } } diff --git a/QueryBuilder/Exceptions/CreateTableQuery/AutoIncrementOrIdentityExceededException.cs b/QueryBuilder/Exceptions/CreateTableQuery/AutoIncrementOrIdentityExceededException.cs new file mode 100644 index 00000000..38bc2f52 --- /dev/null +++ b/QueryBuilder/Exceptions/CreateTableQuery/AutoIncrementOrIdentityExceededException.cs @@ -0,0 +1,24 @@ +using System; +using System.Runtime.Serialization; + +namespace SqlKata.Exceptions.CreateTableQuery +{ + public class AutoIncrementOrIdentityExceededException : Exception + { + public AutoIncrementOrIdentityExceededException() + { + } + + public AutoIncrementOrIdentityExceededException(string message) : base(message) + { + } + + public AutoIncrementOrIdentityExceededException(string message, Exception innerException) : base(message, innerException) + { + } + + protected AutoIncrementOrIdentityExceededException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} From 0b9f44bedaeefde4e7891d5994467f86f1be22bb Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 28 Jun 2023 01:21:04 +0430 Subject: [PATCH 06/33] sql server compiler is now completed --- QueryBuilder/Compilers/SqlServerCompiler.cs | 28 ++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 228a5c20..120bdd8e 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,5 +1,7 @@ using SqlKata.Clauses; using SqlKata.Contract.CreateTable; +using SqlKata.DbTypes; +using SqlKata.Exceptions.CreateTableQuery; using System.Linq; using System.Text; @@ -198,12 +200,32 @@ protected override SqlResult CompileCreateTable(Query query) if(tableType == TableType.Temporary) tableName = new StringBuilder("#").Append(tableName).ToString(); - var queryString = new StringBuilder($"Create Table {tableName} "); + var queryString = new StringBuilder($"CREATE TABLE {tableName} "); queryString.Append("(\n"); - var createTableColumnCluases = - + var createTableColumnCluases = result.Query.GetComponents("CreateTableColumn"); + var identityAndAutoIncrementColumns = createTableColumnCluases.Where(x => x.IsIdentity || x.IsAutoIncrement); + if(identityAndAutoIncrementColumns.Count() > 1) + { + throw new AutoIncrementOrIdentityExceededException("sql server table can not have more than one auto increment or identity column"); + } + foreach(var columnCluase in identityAndAutoIncrementColumns) + { + if(columnCluase.IsIdentity || columnCluase.IsAutoIncrement) + { + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType} IDENTITY(1,1),\n"); + } + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType},\n"); + } + var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); + if (primaryKeys.Any()) + queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys))); + var uniqeColumns = createTableColumnCluases.Where(column => column.IsUnique).ToList(); + for (var i = 0; i < uniqeColumns.Count();i++) + { + queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}),"); + } queryString.Append(")\n"); result.RawSql = queryString.ToString(); return result; From 762f5d6964f288f7671c4121fe22875f3456bc5c Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 28 Jun 2023 01:30:27 +0430 Subject: [PATCH 07/33] Debugging sql server compiler has been started --- Program/Program.cs | 29 +++++++++++++++++++++++++++-- QueryBuilder/Query.CreateTable.cs | 7 +++++-- 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index 9b4c2845..92f57c64 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -13,6 +13,7 @@ using System.Data.SQLite; using static SqlKata.Expressions; using System.IO; +using SqlKata.Contract.CreateTable; namespace Program { @@ -34,7 +35,31 @@ private class Installment static void Main(string[] args) { - using (var db = SqlLiteQueryFactory()) + var query = new Query("Users").CreateTable(new List() + { + new TableColumnDefenitionDto() + { + ColumnName= "id", + ColumnDbType = SqlDbType.Int, + IsAutoIncrement=false, + IsNullable=false, + IsPrimaryKey=true, + IsUnique=false, + }, + new TableColumnDefenitionDto() + { + ColumnName= "FullName", + ColumnDbType = SqlDbType.Text, + IsAutoIncrement=false, + IsNullable=false, + IsPrimaryKey=true, + IsUnique=false, + } + },TableType.Permanent); + var compiler = new SqlServerCompiler(); + Console.WriteLine(compiler.Compile(query)); + +/* using (var db = SqlLiteQueryFactory()) { var query = db.Query("accounts") .Where("balance", ">", 0) @@ -46,7 +71,7 @@ static void Main(string[] args) var exists = query.Clone().Exists(); Console.WriteLine(exists); - } + }*/ } private static void log(Compiler compiler, Query query) diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index 48a4cd8f..b8165c6d 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -7,19 +7,21 @@ namespace SqlKata { public partial class Query { - public void CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent) + public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent) { Method = "CreateTable"; ClearComponent("TableType").AddComponent("TableType",new TableCluase() { - TableType = tableType + TableType = tableType, + Component = "TableType" }); columns.ToList().ForEach(column => { AddComponent("CreateTableColumn",new CreateTableColumn() { + Component = "CreateTableColumn", ColumnName = column.ColumnName, ColumnDbType = column.ColumnDbType, IsNullable = column.IsNullable, @@ -29,6 +31,7 @@ public void CreateTable(IEnumerable columns,TableType IsIdentity = column.IsIdentity }); }); + return this; } } From 2b8b9c9a3f1d5437e2c2dc05fef27c318dc34ea7 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 28 Jun 2023 01:38:39 +0430 Subject: [PATCH 08/33] sql server compiler has been corrected but some small changes needs to be done --- QueryBuilder/Clauses/ColumnClause.cs | 1 + QueryBuilder/Clauses/TableCluase.cs | 1 + QueryBuilder/Compilers/SqlServerCompiler.cs | 4 ++-- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index f3339b1f..6e1b3263 100644 --- a/QueryBuilder/Clauses/ColumnClause.cs +++ b/QueryBuilder/Clauses/ColumnClause.cs @@ -43,6 +43,7 @@ public override AbstractClause Clone() { return new CreateTableColumn { + Component= Component, ColumnDbType= ColumnDbType, ColumnName= ColumnName, IsAutoIncrement= IsAutoIncrement, diff --git a/QueryBuilder/Clauses/TableCluase.cs b/QueryBuilder/Clauses/TableCluase.cs index 6ba53ed4..fdf07b9d 100644 --- a/QueryBuilder/Clauses/TableCluase.cs +++ b/QueryBuilder/Clauses/TableCluase.cs @@ -10,6 +10,7 @@ public override AbstractClause Clone() return new TableCluase() { TableType = TableType, + Component = Component }; } } diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 120bdd8e..4673a4e0 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -209,7 +209,7 @@ protected override SqlResult CompileCreateTable(Query query) { throw new AutoIncrementOrIdentityExceededException("sql server table can not have more than one auto increment or identity column"); } - foreach(var columnCluase in identityAndAutoIncrementColumns) + foreach(var columnCluase in createTableColumnCluases) { if(columnCluase.IsIdentity || columnCluase.IsAutoIncrement) { @@ -219,7 +219,7 @@ protected override SqlResult CompileCreateTable(Query query) } var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); if (primaryKeys.Any()) - queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys))); + queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); var uniqeColumns = createTableColumnCluases.Where(column => column.IsUnique).ToList(); for (var i = 0; i < uniqeColumns.Count();i++) From 5aa0cb41c885179cb5751c5e94a16fc9970a7cf8 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Fri, 30 Jun 2023 16:24:38 +0330 Subject: [PATCH 09/33] Correct DbType for creating table in db --- Program/Program.cs | 13 +++++++-- QueryBuilder/Clauses/ColumnClause.cs | 4 ++- QueryBuilder/Compilers/SqlServerCompiler.cs | 4 +-- .../CreateTable/TableColumnDefenitionDto.cs | 4 ++- QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs | 29 +++++++++++++++++++ .../DbTypes/DbColumn/MySqlDBColumn.cs | 17 +++++++++++ .../DbTypes/DbColumn/OracleDBColumn.cs | 17 +++++++++++ .../DbTypes/DbColumn/PostgresqlDBColumn.cs | 17 +++++++++++ .../DbTypes/DbColumn/SqlServerDBColumn.cs | 17 +++++++++++ .../DbTypes/{ => Enums}/MySqlDbType.cs | 2 +- .../DbTypes/{ => Enums}/OracleDbType.cs | 2 +- .../DbTypes/{ => Enums}/PostgresqlDbType.cs | 2 +- .../DbTypes/{ => Enums}/SqlServerDbType.cs | 2 +- 13 files changed, 120 insertions(+), 10 deletions(-) create mode 100644 QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs create mode 100644 QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs create mode 100644 QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs create mode 100644 QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs create mode 100644 QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs rename QueryBuilder/DbTypes/{ => Enums}/MySqlDbType.cs (93%) rename QueryBuilder/DbTypes/{ => Enums}/OracleDbType.cs (96%) rename QueryBuilder/DbTypes/{ => Enums}/PostgresqlDbType.cs (96%) rename QueryBuilder/DbTypes/{ => Enums}/SqlServerDbType.cs (93%) diff --git a/Program/Program.cs b/Program/Program.cs index 92f57c64..cc88970d 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -14,6 +14,8 @@ using static SqlKata.Expressions; using System.IO; using SqlKata.Contract.CreateTable; +using SqlKata.DbTypes.DbColumn; +using SqlKata.DbTypes.Enums; namespace Program { @@ -40,7 +42,10 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "id", - ColumnDbType = SqlDbType.Int, + ColumnDbType = new SqlServerDBColumn() + { + SqlServerDbType = SqlServerDbType.Int + }, IsAutoIncrement=false, IsNullable=false, IsPrimaryKey=true, @@ -49,7 +54,11 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "FullName", - ColumnDbType = SqlDbType.Text, + ColumnDbType = new SqlServerDBColumn() + { + SqlServerDbType = SqlServerDbType.Varchar, + Length = 30 + }, IsAutoIncrement=false, IsNullable=false, IsPrimaryKey=true, diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index 6e1b3263..aa25d939 100644 --- a/QueryBuilder/Clauses/ColumnClause.cs +++ b/QueryBuilder/Clauses/ColumnClause.cs @@ -1,3 +1,5 @@ +using SqlKata.DbTypes.DbColumn; + namespace SqlKata { public abstract class AbstractColumn : AbstractClause @@ -33,7 +35,7 @@ public override AbstractClause Clone() public class CreateTableColumn : AbstractClause { public string ColumnName { get; set; } - public object ColumnDbType { get; set; } + public BaseDBColumn ColumnDbType { get; set; } public bool IsNullable { get; set; } public bool IsPrimaryKey { get; set; } public bool IsUnique { get; set; } diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 4673a4e0..d98d69a5 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -213,9 +213,9 @@ protected override SqlResult CompileCreateTable(Query query) { if(columnCluase.IsIdentity || columnCluase.IsAutoIncrement) { - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType} IDENTITY(1,1),\n"); + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} IDENTITY(1,1),\n"); } - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType},\n"); + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()},\n"); } var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); if (primaryKeys.Any()) diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs index ae797288..79ac645d 100644 --- a/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs @@ -1,9 +1,11 @@ +using SqlKata.DbTypes.DbColumn; + namespace SqlKata.Contract.CreateTable { public class TableColumnDefenitionDto { public string ColumnName { get; set; } - public object ColumnDbType { get; set; } + public BaseDBColumn ColumnDbType { get; set; } public bool IsNullable { get; set; } public bool IsPrimaryKey { get; set; } public bool IsUnique { get; set; } diff --git a/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs new file mode 100644 index 00000000..38e3315a --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs @@ -0,0 +1,29 @@ +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public abstract class BaseDBColumn + { + public int? Length { get; set; } + public int? Precision { get; set; } + internal abstract string GetDBType(); + + protected void AddLengthAndPrecisionToType(StringBuilder stringBuilder) + { + if (Length.HasValue || Precision.HasValue) + { + stringBuilder.Append('('); + if (Length.HasValue) + { + stringBuilder.Append(Length.Value.ToString()); + } + if (Precision.HasValue) + { + stringBuilder.Append(","); + stringBuilder.Append(Precision.Value.ToString()); + } + stringBuilder.Append(")"); + } + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs new file mode 100644 index 00000000..53f0604b --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs @@ -0,0 +1,17 @@ +using SqlKata.DbTypes.Enums; +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public class MySqlDBColumn : BaseDBColumn + { + public MySqlDbType MySqlDbType { get; set; } + + internal override string GetDBType() + { + var stringBuilder = new StringBuilder(MySqlDbType.ToString()); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs new file mode 100644 index 00000000..cbe341e9 --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs @@ -0,0 +1,17 @@ +using SqlKata.DbTypes.Enums; +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public class OracleDBColumn : BaseDBColumn + { + public OracleDbType OracleDbType { get; set; } + + internal override string GetDBType() + { + var stringBuilder = new StringBuilder(OracleDbType.ToString()); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs new file mode 100644 index 00000000..7971f293 --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs @@ -0,0 +1,17 @@ +using SqlKata.DbTypes.Enums; +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public class PostgresqlDBColumn : BaseDBColumn + { + public PostgresqlDbType PostgresqlDbType { get; set; } + + internal override string GetDBType() + { + var stringBuilder = new StringBuilder(PostgresqlDbType.ToString()); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs new file mode 100644 index 00000000..4bfb8929 --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs @@ -0,0 +1,17 @@ +using SqlKata.DbTypes.Enums; +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public class SqlServerDBColumn : BaseDBColumn + { + public SqlServerDbType SqlServerDbType { get; set; } + + internal override string GetDBType() + { + var stringBuilder = new StringBuilder(SqlServerDbType.ToString()); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/MySqlDbType.cs b/QueryBuilder/DbTypes/Enums/MySqlDbType.cs similarity index 93% rename from QueryBuilder/DbTypes/MySqlDbType.cs rename to QueryBuilder/DbTypes/Enums/MySqlDbType.cs index 642d28e2..6981def9 100644 --- a/QueryBuilder/DbTypes/MySqlDbType.cs +++ b/QueryBuilder/DbTypes/Enums/MySqlDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.DbTypes +namespace SqlKata.DbTypes.Enums { public enum MySqlDbType { diff --git a/QueryBuilder/DbTypes/OracleDbType.cs b/QueryBuilder/DbTypes/Enums/OracleDbType.cs similarity index 96% rename from QueryBuilder/DbTypes/OracleDbType.cs rename to QueryBuilder/DbTypes/Enums/OracleDbType.cs index 8780ed65..87c5d0f0 100644 --- a/QueryBuilder/DbTypes/OracleDbType.cs +++ b/QueryBuilder/DbTypes/Enums/OracleDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.DbTypes +namespace SqlKata.DbTypes.Enums { public enum OracleDbType { diff --git a/QueryBuilder/DbTypes/PostgresqlDbType.cs b/QueryBuilder/DbTypes/Enums/PostgresqlDbType.cs similarity index 96% rename from QueryBuilder/DbTypes/PostgresqlDbType.cs rename to QueryBuilder/DbTypes/Enums/PostgresqlDbType.cs index 99b6dc9a..84d37ac0 100644 --- a/QueryBuilder/DbTypes/PostgresqlDbType.cs +++ b/QueryBuilder/DbTypes/Enums/PostgresqlDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.DbTypes +namespace SqlKata.DbTypes.Enums { public enum PostgresqlDbType { diff --git a/QueryBuilder/DbTypes/SqlServerDbType.cs b/QueryBuilder/DbTypes/Enums/SqlServerDbType.cs similarity index 93% rename from QueryBuilder/DbTypes/SqlServerDbType.cs rename to QueryBuilder/DbTypes/Enums/SqlServerDbType.cs index 384efbd8..65290d65 100644 --- a/QueryBuilder/DbTypes/SqlServerDbType.cs +++ b/QueryBuilder/DbTypes/Enums/SqlServerDbType.cs @@ -1,4 +1,4 @@ -namespace SqlKata.DbTypes +namespace SqlKata.DbTypes.Enums { public enum SqlServerDbType { From 6dea909d3d405fe7581c9e81202d3236de7a5540 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Fri, 30 Jun 2023 17:27:20 +0330 Subject: [PATCH 10/33] Correct and refactor create table --- Program/Program.cs | 4 +- QueryBuilder/Compilers/Compiler.cs | 11 +--- .../Abstractions/ISqlCreateCommandUtil.cs | 10 ++++ .../CreateCompilers/MySqlCreateCommandUtil.cs | 20 +++++++ .../OracleCreateCommandUtil.cs | 21 +++++++ .../PostgresqlCreateCommandUtil.cs | 20 +++++++ .../SqlServerCreateCommandUtil.cs | 19 +++++++ .../Compilers/DDLCompiler/DbDDLCompiler.cs | 57 +++++++++++++++++++ QueryBuilder/Compilers/FirebirdCompiler.cs | 5 ++ QueryBuilder/Compilers/MySqlCompiler.cs | 8 +++ QueryBuilder/Compilers/OracleCompiler.cs | 7 +++ QueryBuilder/Compilers/PostgresCompiler.cs | 7 +++ QueryBuilder/Compilers/SqlServerCompiler.cs | 39 +------------ QueryBuilder/Compilers/SqliteCompiler.cs | 5 ++ 14 files changed, 186 insertions(+), 47 deletions(-) create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs diff --git a/Program/Program.cs b/Program/Program.cs index cc88970d..719fdd52 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -61,8 +61,8 @@ static void Main(string[] args) }, IsAutoIncrement=false, IsNullable=false, - IsPrimaryKey=true, - IsUnique=false, + IsPrimaryKey=false, + IsUnique=true, } },TableType.Permanent); var compiler = new SqlServerCompiler(); diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index 9202f413..ceaff3a2 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -5,7 +5,7 @@ namespace SqlKata.Compilers { - public partial class Compiler + public abstract partial class Compiler { private readonly ConditionsCompilerProvider _compileConditionMethodsProvider; protected virtual string parameterPlaceholder { get; set; } = "?"; @@ -236,14 +236,7 @@ protected virtual SqlResult CompileSelectQuery(Query query) /// /// /// - protected virtual SqlResult CompileCreateTable(Query query) - { - var ctx = new SqlResult() - { - Query= query.Clone(), - }; - return ctx; - } + protected abstract SqlResult CompileCreateTable(Query query); protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) { var ctx = new SqlResult(); diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs new file mode 100644 index 00000000..3816ff69 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs @@ -0,0 +1,10 @@ +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ISqlCreateCommandUtil + { + string CreateTableCommandGenerator(TableType tableType,string tableName); + string AutoIncrementIdentityCommandGenerator(); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs new file mode 100644 index 00000000..6ab86625 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs @@ -0,0 +1,20 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +{ + internal class MySqlCreateCommandUtil : ISqlCreateCommandUtil + { + public string AutoIncrementIdentityCommandGenerator() + { + return " AUTO_INCREMENT "; + } + + public string CreateTableCommandGenerator(TableType tableType, string tableName) + { + if (tableType == TableType.Temporary) + return $"CREATE TEMPORARY TABLE {tableName} "; + return $"CREATE TABLE {tableName} "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs new file mode 100644 index 00000000..300652d3 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs @@ -0,0 +1,21 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +{ + internal class OracleCreateCommandUtil : ISqlCreateCommandUtil + { + public string AutoIncrementIdentityCommandGenerator() + { + return "GENERATED ALWAYS AS IDENTITY "; + } + + public string CreateTableCommandGenerator(TableType tableType, string tableName) + { + if (tableType == TableType.Temporary) + return $"CREATE GLOBAL TEMPORARY TABLE {tableName} "; + else + return $"CREATE TABLE {tableName} "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs new file mode 100644 index 00000000..7249363c --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs @@ -0,0 +1,20 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +{ + internal class PostgresqlCreateCommandUtil : ISqlCreateCommandUtil + { + public string AutoIncrementIdentityCommandGenerator() + { + return ""; + } + + public string CreateTableCommandGenerator(TableType tableType, string tableName) + { + if (tableType == TableType.Temporary) + return $"CREATE TEMPORARY TABLE {tableName} "; + return $"CREATE TABLE {tableName} "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs new file mode 100644 index 00000000..d73eb8a6 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs @@ -0,0 +1,19 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +{ + internal class SqlServerCreateCommandUtil : ISqlCreateCommandUtil + { + public string AutoIncrementIdentityCommandGenerator() + { + return " IDENTITY(1,1) "; + } + + public string CreateTableCommandGenerator(TableType tableType, string tableName) + { + tableName = tableType == TableType.Temporary ? "#" + tableName : tableName; + return $"CREATE TABLE {tableName} "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs new file mode 100644 index 00000000..1968f2e5 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs @@ -0,0 +1,57 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; +using SqlKata.Exceptions.CreateTableQuery; +using System.Linq; +using System.Text; + +namespace SqlKata.Compilers.DDLCompiler +{ + internal class DbDDLCompiler + { + private readonly ISqlCreateCommandUtil _sqlCommandUtil; + internal DbDDLCompiler(ISqlCreateCommandUtil sqlCreateCommandUtil) + { + _sqlCommandUtil = sqlCreateCommandUtil; + } + + internal SqlResult CompileCreateTable(Query query) + { + var result = new SqlResult() + { + Query = query.Clone(), + }; + var tableName = result.Query.GetOneComponent("from").Table; + var tableType = result.Query.GetOneComponent("TableType").TableType; + var queryString = new StringBuilder(_sqlCommandUtil.CreateTableCommandGenerator(tableType,tableName)); + queryString.Append("(\n"); + var createTableColumnCluases = result.Query.GetComponents("CreateTableColumn"); + + var identityAndAutoIncrementColumns = createTableColumnCluases.Where(x => x.IsIdentity || x.IsAutoIncrement); + if (identityAndAutoIncrementColumns.Count() > 1) + { + throw new AutoIncrementOrIdentityExceededException("table can not have more than one auto increment or identity column"); + } + foreach (var columnCluase in createTableColumnCluases) + { + if (columnCluase.IsIdentity || columnCluase.IsAutoIncrement) + { + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()} ,\n"); + } + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()},\n"); + } + var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); + if (primaryKeys.Any()) + queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); + + var uniqeColumns = createTableColumnCluases.Where(column => column.IsUnique).ToList(); + for (var i = 0; i < uniqeColumns.Count(); i++) + { + queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}), \n"); + } + queryString.Append(")\n"); + result.RawSql = queryString.ToString(); + return result; + } + } +} diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs index 61ab9547..204ccb58 100644 --- a/QueryBuilder/Compilers/FirebirdCompiler.cs +++ b/QueryBuilder/Compilers/FirebirdCompiler.cs @@ -116,5 +116,10 @@ public override string CompileFalse() { return "0"; } + + protected override SqlResult CompileCreateTable(Query query) + { + throw new System.NotImplementedException(); + } } } diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs index 4729125b..cd9acd78 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -1,3 +1,6 @@ +using SqlKata.Compilers.DDLCompiler; +using SqlKata.Compilers.DDLCompiler.CreateCompilers; + namespace SqlKata.Compilers { public class MySqlCompiler : Compiler @@ -45,5 +48,10 @@ public override string CompileLimit(SqlResult ctx) return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}"; } + + protected override SqlResult CompileCreateTable(Query query) + { + return new DbDDLCompiler(new MySqlCreateCommandUtil()).CompileCreateTable(query); + } } } diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 610ec20d..227ab2f6 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,3 +1,5 @@ +using SqlKata.Compilers.DDLCompiler.CreateCompilers; +using SqlKata.Compilers.DDLCompiler; using System; using System.Collections.Generic; using System.Diagnostics; @@ -172,5 +174,10 @@ protected override SqlResult CompileRemainingInsertClauses( ctx.RawSql += " SELECT 1 FROM DUAL"; return ctx; } + + protected override SqlResult CompileCreateTable(Query query) + { + return new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); + } } } diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs index 3b45d0e6..8da1974d 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -1,3 +1,5 @@ +using SqlKata.Compilers.DDLCompiler.CreateCompilers; +using SqlKata.Compilers.DDLCompiler; using System; using System.Linq; @@ -95,5 +97,10 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond return sql; } + + protected override SqlResult CompileCreateTable(Query query) + { + return new DbDDLCompiler(new PostgresqlCreateCommandUtil()).CompileCreateTable(query); + } } } diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index d98d69a5..98bb499a 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,4 +1,6 @@ using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.CreateCompilers; +using SqlKata.Compilers.DDLCompiler; using SqlKata.Contract.CreateTable; using SqlKata.DbTypes; using SqlKata.Exceptions.CreateTableQuery; @@ -194,42 +196,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) protected override SqlResult CompileCreateTable(Query query) { - var result = base.CompileCreateTable(query); - var tableName = result.Query.GetOneComponent("from", EngineCode).Table; - var tableType = result.Query.GetOneComponent("TableType").TableType; - if(tableType == TableType.Temporary) - tableName = new StringBuilder("#").Append(tableName).ToString(); - - var queryString = new StringBuilder($"CREATE TABLE {tableName} "); - queryString.Append("(\n"); - var createTableColumnCluases = result.Query.GetComponents("CreateTableColumn"); - - var identityAndAutoIncrementColumns = createTableColumnCluases.Where(x => x.IsIdentity || x.IsAutoIncrement); - if(identityAndAutoIncrementColumns.Count() > 1) - { - throw new AutoIncrementOrIdentityExceededException("sql server table can not have more than one auto increment or identity column"); - } - foreach(var columnCluase in createTableColumnCluases) - { - if(columnCluase.IsIdentity || columnCluase.IsAutoIncrement) - { - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} IDENTITY(1,1),\n"); - } - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()},\n"); - } - var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); - if (primaryKeys.Any()) - queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); - - var uniqeColumns = createTableColumnCluases.Where(column => column.IsUnique).ToList(); - for (var i = 0; i < uniqeColumns.Count();i++) - { - queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}),"); - } - queryString.Append(")\n"); - result.RawSql = queryString.ToString(); - return result; + return new DbDDLCompiler(new SqlServerCreateCommandUtil()).CompileCreateTable(query); } - } } diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs index 1401dd35..6b8d61c4 100644 --- a/QueryBuilder/Compilers/SqliteCompiler.cs +++ b/QueryBuilder/Compilers/SqliteCompiler.cs @@ -63,5 +63,10 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond return sql; } + + protected override SqlResult CompileCreateTable(Query query) + { + throw new System.NotImplementedException(); + } } } From 6fd41373c5f0f4b0304fa062d4b571c072e785d1 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Fri, 30 Jun 2023 17:49:03 +0330 Subject: [PATCH 11/33] Create Table in all dbs was ok --- Program/Program.cs | 14 +++++++------- QueryBuilder.Tests/Infrastructure/TestCompiler.cs | 5 +++++ QueryBuilder/Clauses/ColumnClause.cs | 1 + .../CreateCompilers/MySqlCreateCommandUtil.cs | 2 +- .../CreateCompilers/SqlServerCreateCommandUtil.cs | 2 +- .../Compilers/DDLCompiler/DbDDLCompiler.cs | 6 ++++-- 6 files changed, 19 insertions(+), 11 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index 719fdd52..d76b4dd0 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -42,11 +42,11 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "id", - ColumnDbType = new SqlServerDBColumn() + ColumnDbType = new OracleDBColumn() { - SqlServerDbType = SqlServerDbType.Int + OracleDbType = OracleDbType.Int32 }, - IsAutoIncrement=false, + IsAutoIncrement=true, IsNullable=false, IsPrimaryKey=true, IsUnique=false, @@ -54,9 +54,9 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "FullName", - ColumnDbType = new SqlServerDBColumn() + ColumnDbType = new OracleDBColumn() { - SqlServerDbType = SqlServerDbType.Varchar, + OracleDbType = OracleDbType.Raw, Length = 30 }, IsAutoIncrement=false, @@ -64,8 +64,8 @@ static void Main(string[] args) IsPrimaryKey=false, IsUnique=true, } - },TableType.Permanent); - var compiler = new SqlServerCompiler(); + },TableType.Temporary); + var compiler = new OracleCompiler(); Console.WriteLine(compiler.Compile(query)); /* using (var db = SqlLiteQueryFactory()) diff --git a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs index aded9fd1..fd4a6e01 100644 --- a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs +++ b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs @@ -15,6 +15,11 @@ public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string me { return FindCompilerMethodInfo(clauseType, methodName); } + + protected override SqlResult CompileCreateTable(Query query) + { + throw new NotImplementedException(); + } } class TestSqlServerCompiler : SqlServerCompiler diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index aa25d939..8864efb9 100644 --- a/QueryBuilder/Clauses/ColumnClause.cs +++ b/QueryBuilder/Clauses/ColumnClause.cs @@ -52,6 +52,7 @@ public override AbstractClause Clone() IsPrimaryKey= IsPrimaryKey, IsUnique= IsUnique, IsIdentity= IsIdentity, + IsNullable= IsNullable, }; } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs index 6ab86625..79cca927 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs @@ -7,7 +7,7 @@ internal class MySqlCreateCommandUtil : ISqlCreateCommandUtil { public string AutoIncrementIdentityCommandGenerator() { - return " AUTO_INCREMENT "; + return "AUTO_INCREMENT "; } public string CreateTableCommandGenerator(TableType tableType, string tableName) diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs index d73eb8a6..4a738434 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs @@ -7,7 +7,7 @@ internal class SqlServerCreateCommandUtil : ISqlCreateCommandUtil { public string AutoIncrementIdentityCommandGenerator() { - return " IDENTITY(1,1) "; + return "IDENTITY(1,1) "; } public string CreateTableCommandGenerator(TableType tableType, string tableName) diff --git a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs index 1968f2e5..476db592 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs @@ -34,11 +34,13 @@ internal SqlResult CompileCreateTable(Query query) } foreach (var columnCluase in createTableColumnCluases) { + var nullOrNot = columnCluase.IsNullable ? "NULL " : "NOT NULL "; if (columnCluase.IsIdentity || columnCluase.IsAutoIncrement) { - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()} ,\n"); + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); + continue; } - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()},\n"); + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {nullOrNot},\n"); } var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); if (primaryKeys.Any()) From f32afe2ec52842d0589fc42a2b17ec4b96e997d8 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Fri, 30 Jun 2023 18:02:18 +0330 Subject: [PATCH 12/33] Add Sqlite for creating table --- .../SqliteCreateColmmandUtil.cs | 20 +++++++++++++ .../DbTypes/DbColumn/SqliteDBColumn.cs | 17 +++++++++++ QueryBuilder/DbTypes/Enums/SqliteDbType.cs | 30 +++++++++++++++++++ 3 files changed, 67 insertions(+) create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs create mode 100644 QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs create mode 100644 QueryBuilder/DbTypes/Enums/SqliteDbType.cs diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs new file mode 100644 index 00000000..b1d982fc --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs @@ -0,0 +1,20 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +{ + internal class SqliteCreateColmmandUtil : ISqlCreateCommandUtil + { + public string AutoIncrementIdentityCommandGenerator() + { + return "AUTOINCREMENT "; + } + + public string CreateTableCommandGenerator(TableType tableType, string tableName) + { + if (tableType == TableType.Temporary) + return $"CREATE TEMPORARY TABLE {tableName}"; + return $"CREATE TABLE {tableName}"; + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs new file mode 100644 index 00000000..5d12e2d7 --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs @@ -0,0 +1,17 @@ +using SqlKata.DbTypes.Enums; +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + internal class SqliteDBColumn : BaseDBColumn + { + public SqliteDbType SqliteDbType { get; set; } + + internal override string GetDBType() + { + var stringBuilder = new StringBuilder(SqliteDbType.ToString()); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/Enums/SqliteDbType.cs b/QueryBuilder/DbTypes/Enums/SqliteDbType.cs new file mode 100644 index 00000000..97e49b78 --- /dev/null +++ b/QueryBuilder/DbTypes/Enums/SqliteDbType.cs @@ -0,0 +1,30 @@ +namespace SqlKata.DbTypes.Enums +{ + public enum SqliteDbType + { + BigInt, + Blob, + Boolean, + Byte, + Currency, + Date, + DateTime, + Decimal, + Double, + Guid, + Int16, + Int32, + Int64, + Object, + SByte, + Single, + String, + Time, + UInt16, + UInt32, + UInt64, + VarNumeric, + AnsiString + + } +} From f479f944d1a2a6da25fe9d96627a514a7de07d9a Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Fri, 30 Jun 2023 20:04:55 +0330 Subject: [PATCH 13/33] Refactor and fix the type conversion --- Program/Program.cs | 10 +++++----- QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs | 2 +- QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs | 2 +- QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs | 2 +- QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs | 2 +- QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs | 2 +- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index d76b4dd0..9bb19a6a 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -42,9 +42,9 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "id", - ColumnDbType = new OracleDBColumn() + ColumnDbType = new PostgresqlDBColumn() { - OracleDbType = OracleDbType.Int32 + PostgresqlDbType = PostgresqlDbType.Integer }, IsAutoIncrement=true, IsNullable=false, @@ -54,9 +54,9 @@ static void Main(string[] args) new TableColumnDefenitionDto() { ColumnName= "FullName", - ColumnDbType = new OracleDBColumn() + ColumnDbType = new PostgresqlDBColumn() { - OracleDbType = OracleDbType.Raw, + PostgresqlDbType = PostgresqlDbType.Character_varying, Length = 30 }, IsAutoIncrement=false, @@ -65,7 +65,7 @@ static void Main(string[] args) IsUnique=true, } },TableType.Temporary); - var compiler = new OracleCompiler(); + var compiler = new PostgresCompiler(); Console.WriteLine(compiler.Compile(query)); /* using (var db = SqlLiteQueryFactory()) diff --git a/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs index 53f0604b..489f6dfb 100644 --- a/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/MySqlDBColumn.cs @@ -9,7 +9,7 @@ public class MySqlDBColumn : BaseDBColumn internal override string GetDBType() { - var stringBuilder = new StringBuilder(MySqlDbType.ToString()); + var stringBuilder = new StringBuilder(MySqlDbType.ToString().Replace("_"," ")); AddLengthAndPrecisionToType(stringBuilder); return stringBuilder.ToString(); } diff --git a/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs index cbe341e9..5fbbb73f 100644 --- a/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/OracleDBColumn.cs @@ -9,7 +9,7 @@ public class OracleDBColumn : BaseDBColumn internal override string GetDBType() { - var stringBuilder = new StringBuilder(OracleDbType.ToString()); + var stringBuilder = new StringBuilder(OracleDbType.ToString().Replace("_", " ")); AddLengthAndPrecisionToType(stringBuilder); return stringBuilder.ToString(); } diff --git a/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs index 7971f293..9cfb04ae 100644 --- a/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/PostgresqlDBColumn.cs @@ -9,7 +9,7 @@ public class PostgresqlDBColumn : BaseDBColumn internal override string GetDBType() { - var stringBuilder = new StringBuilder(PostgresqlDbType.ToString()); + var stringBuilder = new StringBuilder(PostgresqlDbType.ToString().Replace("_", " ")); AddLengthAndPrecisionToType(stringBuilder); return stringBuilder.ToString(); } diff --git a/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs index 4bfb8929..060f3ef0 100644 --- a/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/SqlServerDBColumn.cs @@ -9,7 +9,7 @@ public class SqlServerDBColumn : BaseDBColumn internal override string GetDBType() { - var stringBuilder = new StringBuilder(SqlServerDbType.ToString()); + var stringBuilder = new StringBuilder(SqlServerDbType.ToString().Replace("_", " ")); AddLengthAndPrecisionToType(stringBuilder); return stringBuilder.ToString(); } diff --git a/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs index 5d12e2d7..bc59d106 100644 --- a/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs @@ -9,7 +9,7 @@ internal class SqliteDBColumn : BaseDBColumn internal override string GetDBType() { - var stringBuilder = new StringBuilder(SqliteDbType.ToString()); + var stringBuilder = new StringBuilder(SqliteDbType.ToString().Replace("_", " ")); AddLengthAndPrecisionToType(stringBuilder); return stringBuilder.ToString(); } From f9a5c0f51bfa77d6e488edad875a2ac9ba074335 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Sat, 1 Jul 2023 21:24:26 +0330 Subject: [PATCH 14/33] fix some bugs --- .../DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs | 1 - QueryBuilder/QueryBuilder.csproj | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs index 4a738434..c7d163ce 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs @@ -12,7 +12,6 @@ public string AutoIncrementIdentityCommandGenerator() public string CreateTableCommandGenerator(TableType tableType, string tableName) { - tableName = tableType == TableType.Temporary ? "#" + tableName : tableName; return $"CREATE TABLE {tableName} "; } } diff --git a/QueryBuilder/QueryBuilder.csproj b/QueryBuilder/QueryBuilder.csproj index 5ce65d65..0129e174 100755 --- a/QueryBuilder/QueryBuilder.csproj +++ b/QueryBuilder/QueryBuilder.csproj @@ -23,6 +23,8 @@ true true CS1591 + 2.4.0 + 2.4.0 bin\Debug\netstandard2.0\SqlKata.xml From ac56c0115ff44336bf5756686ffc562f6b2957b7 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Sat, 1 Jul 2023 21:30:05 +0330 Subject: [PATCH 15/33] fix bug in creating table in postgresql --- .../Compilers/DDLCompiler/DbDDLCompiler.cs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs index 476db592..46e13fb9 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs @@ -4,6 +4,7 @@ using SqlKata.Exceptions.CreateTableQuery; using System.Linq; using System.Text; +using System.Xml; namespace SqlKata.Compilers.DDLCompiler { @@ -52,8 +53,19 @@ internal SqlResult CompileCreateTable(Query query) queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}), \n"); } queryString.Append(")\n"); - result.RawSql = queryString.ToString(); + result.RawSql = RefineQueryString(queryString.ToString()); + result.RawSql.LastIndexOf(","); return result; } + + private string RefineQueryString(string queryString) + { + var lastCommaChar = queryString.LastIndexOf(','); + if(lastCommaChar != -1) + queryString = queryString.Remove(lastCommaChar,1); + return queryString; + } + + } } From 05c882ebd1dae0df0ec27532ebef68e3e68ecdd3 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Sun, 2 Jul 2023 20:52:29 +0330 Subject: [PATCH 16/33] oracle create query add ON COMMIT PRESERVE ROWS --- QueryBuilder/Compilers/OracleCompiler.cs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 227ab2f6..41c46e6f 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -10,6 +10,7 @@ namespace SqlKata.Compilers { public class OracleCompiler : Compiler { + private const string CreateTableCondition = "ON COMMIT PRESERVE ROWS"; public OracleCompiler() { ColumnAsKeyword = ""; @@ -177,7 +178,9 @@ protected override SqlResult CompileRemainingInsertClauses( protected override SqlResult CompileCreateTable(Query query) { - return new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); + var result = new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); + result.RawSql = result.RawSql + CreateTableCondition; + return result; } } } From 9f85db92ca4194a1a5f9d962f2454539f7edfa09 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Sun, 2 Jul 2023 20:54:03 +0330 Subject: [PATCH 17/33] revert the last change --- QueryBuilder/Compilers/OracleCompiler.cs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 41c46e6f..adda84bf 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -178,9 +178,7 @@ protected override SqlResult CompileRemainingInsertClauses( protected override SqlResult CompileCreateTable(Query query) { - var result = new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); - result.RawSql = result.RawSql + CreateTableCondition; - return result; + return new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); } } } From 97d87a4316d6b1a304c3eaf078b67af937001c29 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 14:53:35 +0330 Subject: [PATCH 18/33] change the structure of creating table query --- .../CreateTableQueryExtensionClause.cs | 24 +++++++ .../Abstractions/IColumnCompiler.cs | 10 +++ .../Abstractions/ICreateTableQueryCompiler.cs | 11 +++ .../DDLCompiler/Abstractions/IDDLCompiler.cs | 7 ++ .../Abstractions/IPrimaryKeyCompiler.cs | 10 +++ .../Abstractions/IUniqueConstraintCompiler.cs | 10 +++ .../ColumnCompilers/ColumnCompiler.cs | 36 ++++++++++ .../GeneralCreateTableCompiler.cs | 34 +++++++++ .../MySqlCreateCommandUtil.cs | 2 +- .../OracleCreateCommandUtil.cs | 2 +- .../PostgresqlCreateCommandUtil.cs | 2 +- .../SqlServerCreateCommandUtil.cs | 2 +- .../SqliteCreateCommandUtil.cs} | 4 +- .../PrimaryKeyCompilers/PrimaryKeyCompiler.cs | 17 +++++ .../UniqueConstraintCompiler.cs | 19 +++++ .../Compilers/DDLCompiler/DDLCompiler.cs | 38 ++++++++++ .../Compilers/DDLCompiler/DbDDLCompiler.cs | 71 ------------------- QueryBuilder/Compilers/Enums/DataSource.cs | 12 ++++ QueryBuilder/Compilers/MySqlCompiler.cs | 5 +- QueryBuilder/Compilers/OracleCompiler.cs | 10 +-- QueryBuilder/Compilers/PostgresCompiler.cs | 4 +- QueryBuilder/Compilers/SqlServerCompiler.cs | 9 +-- .../DbTableSpecific/CreateDbTableExtension.cs | 6 ++ .../OracleDbTableExtensions.cs | 7 ++ QueryBuilder/Query.CreateTable.cs | 12 +++- 25 files changed, 266 insertions(+), 98 deletions(-) create mode 100644 QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs rename QueryBuilder/Compilers/DDLCompiler/{CreateCompilers => CreateTableBuilders/CreateTableQueryUtils}/MySqlCreateCommandUtil.cs (87%) rename QueryBuilder/Compilers/DDLCompiler/{CreateCompilers => CreateTableBuilders/CreateTableQueryUtils}/OracleCreateCommandUtil.cs (88%) rename QueryBuilder/Compilers/DDLCompiler/{CreateCompilers => CreateTableBuilders/CreateTableQueryUtils}/PostgresqlCreateCommandUtil.cs (87%) rename QueryBuilder/Compilers/DDLCompiler/{CreateCompilers => CreateTableBuilders/CreateTableQueryUtils}/SqlServerCreateCommandUtil.cs (84%) rename QueryBuilder/Compilers/DDLCompiler/{CreateCompilers/SqliteCreateColmmandUtil.cs => CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs} (76%) create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs delete mode 100644 QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs create mode 100644 QueryBuilder/Compilers/Enums/DataSource.cs create mode 100644 QueryBuilder/Contract/CreateTable/DbTableSpecific/CreateDbTableExtension.cs create mode 100644 QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs diff --git a/QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs b/QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs new file mode 100644 index 00000000..17f6c3a5 --- /dev/null +++ b/QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs @@ -0,0 +1,24 @@ +using SqlKata.Contract.CreateTable.DbTableSpecific; + +namespace SqlKata.Clauses +{ + /// + /// this clause is for other queries that are supported by specific dbs. for example in oracle we have ON COMMIT PRESERVER ROWS for creating temp table + /// and we do not have this option in other databases like mysql! + /// this can be inherited and used for other dbs. + /// + public class CreateTableQueryExtensionClause : AbstractClause + { + public CreateDbTableExtension CreateDbTableExtension { get; set; } + + public override AbstractClause Clone() + { + return new CreateTableQueryExtensionClause() + { + Component = Component, + Engine = Engine, + CreateDbTableExtension = CreateDbTableExtension + }; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs new file mode 100644 index 00000000..8cb867a3 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; +using System.Text; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface IColumnCompiler + { + void CompileCreateTableColumns(StringBuilder queryString, List createTableColumnClauses); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs new file mode 100644 index 00000000..92561110 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs @@ -0,0 +1,11 @@ +using System.Collections.Generic; +using System.Text; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableQueryCompiler + { + StringBuilder CompileCreateTable(string tableName,TableType tableType,List createTableColumnClauses); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs new file mode 100644 index 00000000..ca6e55dc --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -0,0 +1,7 @@ +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + public interface IDDLCompiler + { + SqlResult CompileCreateTable(Query query); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs new file mode 100644 index 00000000..5a3a8ede --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; +using System.Text; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface IPrimaryKeyCompiler + { + void CompilePrimaryKey(StringBuilder queryString, List createTableColumnClauses); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs new file mode 100644 index 00000000..f36fe63d --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; +using System.Text; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + public interface IUniqueConstraintCompiler + { + void CompileUniqueConstraints(StringBuilder queryString, List createTableColumnClauses); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs new file mode 100644 index 00000000..983e6661 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Exceptions.CreateTableQuery; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers +{ + internal class ColumnCompiler : IColumnCompiler + { + private readonly ISqlCreateCommandUtil _sqlCommandUtil; + + public ColumnCompiler(ISqlCreateCommandUtil sqlCommandUtil) + { + _sqlCommandUtil = sqlCommandUtil; + } + public void CompileCreateTableColumns(StringBuilder queryString, List createTableColumnClauses) + { + var identityAndAutoIncrementColumns = createTableColumnClauses.Where(x => x.IsIdentity || x.IsAutoIncrement); + if (identityAndAutoIncrementColumns.Count() > 1) + { + throw new AutoIncrementOrIdentityExceededException("table can not have more than one auto increment or identity column"); + } + foreach (var columnCluase in createTableColumnClauses) + { + var nullOrNot = columnCluase.IsNullable ? "NULL " : "NOT NULL "; + if (columnCluase.IsIdentity || columnCluase.IsAutoIncrement) + { + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); + continue; + } + queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {nullOrNot},\n"); + } + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs new file mode 100644 index 00000000..9e9cf86d --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs @@ -0,0 +1,34 @@ +using System.Collections.Generic; +using System.Text; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers +{ + internal class GeneralCreateTableCompiler : ICreateTableQueryCompiler + { + private readonly ISqlCreateCommandUtil _sqlCommandUtil; + private readonly IColumnCompiler _columnCompiler; + private readonly IPrimaryKeyCompiler _primaryKeyCompiler; + private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + + public GeneralCreateTableCompiler(ISqlCreateCommandUtil sqlCommandUtil, IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + { + _sqlCommandUtil = sqlCommandUtil; + _columnCompiler = columnCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _uniqueConstraintCompiler = uniqueConstraintCompiler; + } + + public StringBuilder CompileCreateTable(string tableName,TableType tableType,List createTableColumnClauses) + { + var queryString = new StringBuilder(_sqlCommandUtil.CreateTableCommandGenerator(tableType,tableName)); + queryString.Append("(\n"); + _columnCompiler.CompileCreateTableColumns(queryString,createTableColumnClauses); + _primaryKeyCompiler.CompilePrimaryKey(queryString,createTableColumnClauses); + _uniqueConstraintCompiler.CompileUniqueConstraints(queryString,createTableColumnClauses); + queryString.Append(")\n"); + return queryString; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs similarity index 87% rename from QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs index 79cca927..9462e1dd 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/MySqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class MySqlCreateCommandUtil : ISqlCreateCommandUtil { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs similarity index 88% rename from QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs index 300652d3..cfd3a93b 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/OracleCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class OracleCreateCommandUtil : ISqlCreateCommandUtil { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs similarity index 87% rename from QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs index 7249363c..9912ec08 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/PostgresqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class PostgresqlCreateCommandUtil : ISqlCreateCommandUtil { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs similarity index 84% rename from QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs index c7d163ce..babd04bd 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class SqlServerCreateCommandUtil : ISqlCreateCommandUtil { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs similarity index 76% rename from QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs index b1d982fc..9afec05a 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateCompilers/SqliteCreateColmmandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs @@ -1,9 +1,9 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateCompilers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { - internal class SqliteCreateColmmandUtil : ISqlCreateCommandUtil + internal class SqliteCreateCommandUtil : ISqlCreateCommandUtil { public string AutoIncrementIdentityCommandGenerator() { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs new file mode 100644 index 00000000..c2f3b33c --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text; +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.PrimaryKeyCompilers +{ + internal class PrimaryKeyCompiler : IPrimaryKeyCompiler + { + public void CompilePrimaryKey(StringBuilder queryString, List createTableColumnClauses) + { + var primaryKeys = createTableColumnClauses.Where(column => column.IsPrimaryKey); + if (primaryKeys.Any()) + queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs new file mode 100644 index 00000000..6bb4b2c6 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs @@ -0,0 +1,19 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text; +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers +{ + public class UniqueConstraintCompiler : IUniqueConstraintCompiler + { + public void CompileUniqueConstraints(StringBuilder queryString, List createTableColumnClauses) + { + var uniqeColumns = createTableColumnClauses.Where(column => column.IsUnique).ToList(); + for (var i = 0; i < uniqeColumns.Count(); i++) + { + queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}), \n"); + } + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs new file mode 100644 index 00000000..92db6eac --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -0,0 +1,38 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler +{ + internal class DDLCompiler + { + private readonly ICreateTableQueryCompiler _createTableQueryCompiler; + + public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler) + { + _createTableQueryCompiler = createTableQueryCompiler; + } + + + internal SqlResult CompileCreateTable(Query query) + { + var result = new SqlResult() + { + Query = query.Clone(), + }; + var createTableColumnClauses = result.Query.GetComponents("CreateTableColumn"); + var tableName = result.Query.GetOneComponent("from").Table; + var tableType = result.Query.GetOneComponent("TableType").TableType; + var queryString = _createTableQueryCompiler.CompileCreateTable(tableName,tableType,createTableColumnClauses); + result.RawSql = RefineQueryString(queryString.ToString()); + return result; + } + + private static string RefineQueryString(string queryString) + { + var lastCommaChar = queryString.LastIndexOf(','); + if(lastCommaChar != -1) + queryString = queryString.Remove(lastCommaChar,1); + return queryString; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs deleted file mode 100644 index 46e13fb9..00000000 --- a/QueryBuilder/Compilers/DDLCompiler/DbDDLCompiler.cs +++ /dev/null @@ -1,71 +0,0 @@ -using SqlKata.Clauses; -using SqlKata.Compilers.DDLCompiler.Abstractions; -using SqlKata.Contract.CreateTable; -using SqlKata.Exceptions.CreateTableQuery; -using System.Linq; -using System.Text; -using System.Xml; - -namespace SqlKata.Compilers.DDLCompiler -{ - internal class DbDDLCompiler - { - private readonly ISqlCreateCommandUtil _sqlCommandUtil; - internal DbDDLCompiler(ISqlCreateCommandUtil sqlCreateCommandUtil) - { - _sqlCommandUtil = sqlCreateCommandUtil; - } - - internal SqlResult CompileCreateTable(Query query) - { - var result = new SqlResult() - { - Query = query.Clone(), - }; - var tableName = result.Query.GetOneComponent("from").Table; - var tableType = result.Query.GetOneComponent("TableType").TableType; - var queryString = new StringBuilder(_sqlCommandUtil.CreateTableCommandGenerator(tableType,tableName)); - queryString.Append("(\n"); - var createTableColumnCluases = result.Query.GetComponents("CreateTableColumn"); - - var identityAndAutoIncrementColumns = createTableColumnCluases.Where(x => x.IsIdentity || x.IsAutoIncrement); - if (identityAndAutoIncrementColumns.Count() > 1) - { - throw new AutoIncrementOrIdentityExceededException("table can not have more than one auto increment or identity column"); - } - foreach (var columnCluase in createTableColumnCluases) - { - var nullOrNot = columnCluase.IsNullable ? "NULL " : "NOT NULL "; - if (columnCluase.IsIdentity || columnCluase.IsAutoIncrement) - { - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); - continue; - } - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {nullOrNot},\n"); - } - var primaryKeys = createTableColumnCluases.Where(column => column.IsPrimaryKey); - if (primaryKeys.Any()) - queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); - - var uniqeColumns = createTableColumnCluases.Where(column => column.IsUnique).ToList(); - for (var i = 0; i < uniqeColumns.Count(); i++) - { - queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}), \n"); - } - queryString.Append(")\n"); - result.RawSql = RefineQueryString(queryString.ToString()); - result.RawSql.LastIndexOf(","); - return result; - } - - private string RefineQueryString(string queryString) - { - var lastCommaChar = queryString.LastIndexOf(','); - if(lastCommaChar != -1) - queryString = queryString.Remove(lastCommaChar,1); - return queryString; - } - - - } -} diff --git a/QueryBuilder/Compilers/Enums/DataSource.cs b/QueryBuilder/Compilers/Enums/DataSource.cs new file mode 100644 index 00000000..6ca40616 --- /dev/null +++ b/QueryBuilder/Compilers/Enums/DataSource.cs @@ -0,0 +1,12 @@ +namespace SqlKata.Compilers.Enums +{ + internal enum DataSource + { + SqlServer, + Oracle, + Postgresql, + MySql, + Firebird, + Sqlite + } +} diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs index cd9acd78..96eec8fa 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -1,6 +1,3 @@ -using SqlKata.Compilers.DDLCompiler; -using SqlKata.Compilers.DDLCompiler.CreateCompilers; - namespace SqlKata.Compilers { public class MySqlCompiler : Compiler @@ -51,7 +48,7 @@ public override string CompileLimit(SqlResult ctx) protected override SqlResult CompileCreateTable(Query query) { - return new DbDDLCompiler(new MySqlCreateCommandUtil()).CompileCreateTable(query); + return null; } } } diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index adda84bf..124bc1ec 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,10 +1,6 @@ -using SqlKata.Compilers.DDLCompiler.CreateCompilers; -using SqlKata.Compilers.DDLCompiler; using System; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; -using System.Text.RegularExpressions; namespace SqlKata.Compilers { @@ -178,7 +174,11 @@ protected override SqlResult CompileRemainingInsertClauses( protected override SqlResult CompileCreateTable(Query query) { - return new DbDDLCompiler(new OracleCreateCommandUtil()).CompileCreateTable(query); + return null; } + + + + } } diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs index 8da1974d..4adeedbd 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -1,5 +1,3 @@ -using SqlKata.Compilers.DDLCompiler.CreateCompilers; -using SqlKata.Compilers.DDLCompiler; using System; using System.Linq; @@ -100,7 +98,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond protected override SqlResult CompileCreateTable(Query query) { - return new DbDDLCompiler(new PostgresqlCreateCommandUtil()).CompileCreateTable(query); + return null; } } } diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 98bb499a..720feb8e 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,11 +1,4 @@ -using SqlKata.Clauses; -using SqlKata.Compilers.DDLCompiler.CreateCompilers; -using SqlKata.Compilers.DDLCompiler; -using SqlKata.Contract.CreateTable; -using SqlKata.DbTypes; -using SqlKata.Exceptions.CreateTableQuery; using System.Linq; -using System.Text; namespace SqlKata.Compilers { @@ -196,7 +189,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) protected override SqlResult CompileCreateTable(Query query) { - return new DbDDLCompiler(new SqlServerCreateCommandUtil()).CompileCreateTable(query); + return null; } } } diff --git a/QueryBuilder/Contract/CreateTable/DbTableSpecific/CreateDbTableExtension.cs b/QueryBuilder/Contract/CreateTable/DbTableSpecific/CreateDbTableExtension.cs new file mode 100644 index 00000000..f6239d29 --- /dev/null +++ b/QueryBuilder/Contract/CreateTable/DbTableSpecific/CreateDbTableExtension.cs @@ -0,0 +1,6 @@ +namespace SqlKata.Contract.CreateTable.DbTableSpecific +{ + public abstract class CreateDbTableExtension + { + } +} diff --git a/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs new file mode 100644 index 00000000..adf45e89 --- /dev/null +++ b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs @@ -0,0 +1,7 @@ +namespace SqlKata.Contract.CreateTable.DbTableSpecific +{ + public class OracleDbTableExtensions + { + public bool OnCommitPreserveRows { get; set; } + } +} diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index b8165c6d..fa6e2897 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -2,12 +2,13 @@ using SqlKata.Contract.CreateTable; using System.Collections.Generic; using System.Linq; +using SqlKata.Contract.CreateTable.DbTableSpecific; namespace SqlKata { public partial class Query { - public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent) + public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent,CreateDbTableExtension createDbTableExtension = null) { Method = "CreateTable"; @@ -31,6 +32,15 @@ public Query CreateTable(IEnumerable columns,TableType IsIdentity = column.IsIdentity }); }); + + if (createDbTableExtension != null) + { + AddComponent("CreateTableExtension", new CreateTableQueryExtensionClause() + { + CreateDbTableExtension = createDbTableExtension, + Component = "CreateTableExtension" + }); + } return this; } From c50860e1e4824ad713dedb6c32f82fc48f0ffece Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 16:03:56 +0330 Subject: [PATCH 19/33] Create Table Fillers and Formatters --- .../Abstractions/IColumnCompiler.cs | 2 +- .../Abstractions/ICreateQueryFormatFactory.cs | 10 +++++ .../Abstractions/ICreateQueryFormatFiller.cs | 11 ++++++ .../Abstractions/ICreateTableQueryCompiler.cs | 2 +- .../Abstractions/IPrimaryKeyCompiler.cs | 2 +- .../Abstractions/ISqlCreateCommandUtil.cs | 1 - .../Abstractions/IUniqueConstraintCompiler.cs | 4 +- .../ColumnCompilers/ColumnCompiler.cs | 5 ++- .../GeneralCreateTableCompiler.cs | 28 ++++++++++--- .../MySqlCreateCommandUtil.cs | 7 ---- .../OracleCreateCommandUtil.cs | 8 ---- .../PostgresqlCreateCommandUtil.cs | 7 ---- .../SqlServerCreateCommandUtil.cs | 5 --- .../SqliteCreateCommandUtil.cs | 7 ---- .../PrimaryKeyCompilers/PrimaryKeyCompiler.cs | 4 +- .../MySqlCreateTableFormatFactory.cs | 18 +++++++++ .../OracleCreateTableFormatFactory.cs | 19 +++++++++ .../PostgresqlCreateTableFormatFactory.cs | 18 +++++++++ .../SqlServerCreateTableFormatFactory.cs | 19 +++++++++ .../Fillers/MySqlCreateQueryFormatFiller.cs | 37 ++++++++++++++++++ .../Fillers/OracleCreateQueryFormatFiller.cs | 39 +++++++++++++++++++ .../PostgresqlCreateQueryFormatFiller.cs | 38 ++++++++++++++++++ .../SqlServerCreateQueryFormatFiller.cs | 33 ++++++++++++++++ .../UniqueConstraintCompiler.cs | 4 +- .../Compilers/DDLCompiler/DDLCompiler.cs | 14 +------ 25 files changed, 281 insertions(+), 61 deletions(-) create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFiller.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs index 8cb867a3..ea13c314 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs @@ -5,6 +5,6 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface IColumnCompiler { - void CompileCreateTableColumns(StringBuilder queryString, List createTableColumnClauses); + string CompileCreateTableColumns(List createTableColumnClauses); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFactory.cs new file mode 100644 index 00000000..386768c1 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFactory.cs @@ -0,0 +1,10 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateQueryFormatFactory + { + DataSource DataSource { get; } + string CreateTableFormat(); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFiller.cs new file mode 100644 index 00000000..3a4abfee --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateQueryFormatFiller.cs @@ -0,0 +1,11 @@ +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateQueryFormatFiller + { + DataSource DataSource { get; } + string FillQueryFormat(string queryFormat,Query query); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs index 92561110..517125d1 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs @@ -6,6 +6,6 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface ICreateTableQueryCompiler { - StringBuilder CompileCreateTable(string tableName,TableType tableType,List createTableColumnClauses); + string CompileCreateTable(Query query); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs index 5a3a8ede..6067d50e 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs @@ -5,6 +5,6 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface IPrimaryKeyCompiler { - void CompilePrimaryKey(StringBuilder queryString, List createTableColumnClauses); + string CompilePrimaryKey(List createTableColumnClauses); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs index 3816ff69..c7ac42dd 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs @@ -4,7 +4,6 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface ISqlCreateCommandUtil { - string CreateTableCommandGenerator(TableType tableType,string tableName); string AutoIncrementIdentityCommandGenerator(); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs index f36fe63d..a11ac603 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs @@ -3,8 +3,8 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { - public interface IUniqueConstraintCompiler + internal interface IUniqueConstraintCompiler { - void CompileUniqueConstraints(StringBuilder queryString, List createTableColumnClauses); + string CompileUniqueConstraints(List createTableColumnClauses); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs index 983e6661..cda7fb23 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs @@ -14,8 +14,9 @@ public ColumnCompiler(ISqlCreateCommandUtil sqlCommandUtil) { _sqlCommandUtil = sqlCommandUtil; } - public void CompileCreateTableColumns(StringBuilder queryString, List createTableColumnClauses) + public string CompileCreateTableColumns(List createTableColumnClauses) { + var queryString = new StringBuilder(); var identityAndAutoIncrementColumns = createTableColumnClauses.Where(x => x.IsIdentity || x.IsAutoIncrement); if (identityAndAutoIncrementColumns.Count() > 1) { @@ -31,6 +32,8 @@ public void CompileCreateTableColumns(StringBuilder queryString, List createTableColumnClauses) + public string CompileCreateTable(Query query) { - var queryString = new StringBuilder(_sqlCommandUtil.CreateTableCommandGenerator(tableType,tableName)); + /*var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + + var createTableString = _sqlCommandUtil.CreateTableCommandGenerator(tableType, tableName); + var queryString = new StringBuilder(createTableString); queryString.Append("(\n"); _columnCompiler.CompileCreateTableColumns(queryString,createTableColumnClauses); _primaryKeyCompiler.CompilePrimaryKey(queryString,createTableColumnClauses); _uniqueConstraintCompiler.CompileUniqueConstraints(queryString,createTableColumnClauses); - queryString.Append(")\n"); + queryString.Append(")\n");*/ + + /* + return RefineQueryString(queryString.ToString());*/ + return null; + } + + private static string RefineQueryString(string queryString) + { + var lastCommaChar = queryString.LastIndexOf(','); + if(lastCommaChar != -1) + queryString = queryString.Remove(lastCommaChar,1); return queryString; } + } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs index 9462e1dd..437592ed 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs @@ -9,12 +9,5 @@ public string AutoIncrementIdentityCommandGenerator() { return "AUTO_INCREMENT "; } - - public string CreateTableCommandGenerator(TableType tableType, string tableName) - { - if (tableType == TableType.Temporary) - return $"CREATE TEMPORARY TABLE {tableName} "; - return $"CREATE TABLE {tableName} "; - } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs index cfd3a93b..8fbfabe0 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs @@ -9,13 +9,5 @@ public string AutoIncrementIdentityCommandGenerator() { return "GENERATED ALWAYS AS IDENTITY "; } - - public string CreateTableCommandGenerator(TableType tableType, string tableName) - { - if (tableType == TableType.Temporary) - return $"CREATE GLOBAL TEMPORARY TABLE {tableName} "; - else - return $"CREATE TABLE {tableName} "; - } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs index 9912ec08..1ad43674 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs @@ -9,12 +9,5 @@ public string AutoIncrementIdentityCommandGenerator() { return ""; } - - public string CreateTableCommandGenerator(TableType tableType, string tableName) - { - if (tableType == TableType.Temporary) - return $"CREATE TEMPORARY TABLE {tableName} "; - return $"CREATE TABLE {tableName} "; - } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs index babd04bd..5b972015 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs @@ -9,10 +9,5 @@ public string AutoIncrementIdentityCommandGenerator() { return "IDENTITY(1,1) "; } - - public string CreateTableCommandGenerator(TableType tableType, string tableName) - { - return $"CREATE TABLE {tableName} "; - } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs index 9afec05a..00771a0c 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs @@ -9,12 +9,5 @@ public string AutoIncrementIdentityCommandGenerator() { return "AUTOINCREMENT "; } - - public string CreateTableCommandGenerator(TableType tableType, string tableName) - { - if (tableType == TableType.Temporary) - return $"CREATE TEMPORARY TABLE {tableName}"; - return $"CREATE TABLE {tableName}"; - } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs index c2f3b33c..5ba277d6 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs @@ -7,11 +7,13 @@ namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.PrimaryKeyCompilers { internal class PrimaryKeyCompiler : IPrimaryKeyCompiler { - public void CompilePrimaryKey(StringBuilder queryString, List createTableColumnClauses) + public string CompilePrimaryKey(List createTableColumnClauses) { + var queryString = new StringBuilder(); var primaryKeys = createTableColumnClauses.Where(column => column.IsPrimaryKey); if (primaryKeys.Any()) queryString.Append(string.Format("PRIMARY KEY ({0}),\n", string.Join(",", primaryKeys.Select(column => column.ColumnName)))); + return queryString.ToString(); } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs new file mode 100644 index 00000000..2650510d --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs @@ -0,0 +1,18 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +{ + internal class MySqlCreateTableFormatFactory : ICreateQueryFormatFactory + { + public DataSource DataSource { get; } = DataSource.MySql; + public string CreateTableFormat() + { + return @"CREATE {0} TABLE {1} ( + {2}, + {3} + {4} + )"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs new file mode 100644 index 00000000..00a5b68c --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs @@ -0,0 +1,19 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +{ + internal class OracleCreateTableFormatFactory : ICreateQueryFormatFactory + { + public DataSource DataSource { get; } = DataSource.Oracle; + public string CreateTableFormat() + { + return @"CREATE {0} {1} TABLE {2} ( + {3} + {4} + {5} + ) + {6}"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs new file mode 100644 index 00000000..deb3ea80 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs @@ -0,0 +1,18 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +{ + internal class PostgresqlCreateTableFormatFactory : ICreateQueryFormatFactory + { + public DataSource DataSource { get; } = DataSource.Postgresql; + public string CreateTableFormat() + { + return @"CREATE {0} TABLE {1} ( + {2}, + {3} + {4} + )"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs new file mode 100644 index 00000000..04d0e35c --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs @@ -0,0 +1,19 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +{ + internal class SqlServerCreateTableFormatFactory : ICreateQueryFormatFactory + { + public DataSource DataSource { get; } = DataSource.SqlServer; + public string CreateTableFormat() + { + return @"CREATE TABLE {0}( + {1} + {2} + {3} + ) + "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs new file mode 100644 index 00000000..31936fc3 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs @@ -0,0 +1,37 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +{ + internal class MySqlCreateQueryFormatFiller : ICreateQueryFormatFiller + { + private readonly IColumnCompiler _columnCompiler; + private readonly IPrimaryKeyCompiler _primaryKeyCompiler; + private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + + public MySqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + { + _columnCompiler = columnCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _uniqueConstraintCompiler = uniqueConstraintCompiler; + } + + public DataSource DataSource { get; } = DataSource.MySql; + public string FillQueryFormat(string queryFormat,Query query) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempString = tableType == TableType.Temporary ? "TEMPORARY" : ""; + return string.Format(queryFormat, + tempString, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs new file mode 100644 index 00000000..b034d222 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs @@ -0,0 +1,39 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +{ + internal class OracleCreateQueryFormatFiller : ICreateQueryFormatFiller + { + private readonly IColumnCompiler _columnCompiler; + private readonly IPrimaryKeyCompiler _primaryKeyCompiler; + private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + + public OracleCreateQueryFormatFiller(IUniqueConstraintCompiler uniqueConstraintCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IColumnCompiler columnCompiler) + { + _uniqueConstraintCompiler = uniqueConstraintCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _columnCompiler = columnCompiler; + } + + public DataSource DataSource { get; } = DataSource.Oracle; + public string FillQueryFormat(string queryFormat,Query query) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempString = tableType == TableType.Temporary ? "GLOBAL TEMPORARY" : ""; + string hint = ""; + return string.Format(queryFormat, + tempString, + hint, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs new file mode 100644 index 00000000..8b488676 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs @@ -0,0 +1,38 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +{ + internal class PostgresqlCreateQueryFormatFiller : ICreateQueryFormatFiller + { + private readonly IColumnCompiler _columnCompiler; + private readonly IPrimaryKeyCompiler _primaryKeyCompiler; + private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + + public PostgresqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + { + _columnCompiler = columnCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _uniqueConstraintCompiler = uniqueConstraintCompiler; + } + + public DataSource DataSource { get; } = DataSource.Postgresql; + + public string FillQueryFormat(string queryFormat,Query query) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempString = tableType == TableType.Temporary ? "TEMPORARY" : ""; + return string.Format(queryFormat, + tempString, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs new file mode 100644 index 00000000..717639a8 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs @@ -0,0 +1,33 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +{ + internal class SqlServerCreateQueryFormatFiller : ICreateQueryFormatFiller + { + private readonly IColumnCompiler _columnCompiler; + private readonly IPrimaryKeyCompiler _primaryKeyCompiler; + private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + + public SqlServerCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + { + _columnCompiler = columnCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _uniqueConstraintCompiler = uniqueConstraintCompiler; + } + + public DataSource DataSource { get; } = DataSource.SqlServer; + public string FillQueryFormat(string queryFormat,Query query) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + return string.Format(queryFormat, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs index 6bb4b2c6..664b4ecb 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs @@ -7,13 +7,15 @@ namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintComp { public class UniqueConstraintCompiler : IUniqueConstraintCompiler { - public void CompileUniqueConstraints(StringBuilder queryString, List createTableColumnClauses) + public string CompileUniqueConstraints(List createTableColumnClauses) { + var queryString = new StringBuilder(); var uniqeColumns = createTableColumnClauses.Where(column => column.IsUnique).ToList(); for (var i = 0; i < uniqeColumns.Count(); i++) { queryString.Append($"CONSTRAINT unique_constraint_{i} UNIQUE ({uniqeColumns[i].ColumnName}), \n"); } + return queryString.ToString(); } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs index 92db6eac..84bda2bf 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -19,20 +19,10 @@ internal SqlResult CompileCreateTable(Query query) { Query = query.Clone(), }; - var createTableColumnClauses = result.Query.GetComponents("CreateTableColumn"); - var tableName = result.Query.GetOneComponent("from").Table; - var tableType = result.Query.GetOneComponent("TableType").TableType; - var queryString = _createTableQueryCompiler.CompileCreateTable(tableName,tableType,createTableColumnClauses); - result.RawSql = RefineQueryString(queryString.ToString()); + var queryString = _createTableQueryCompiler.CompileCreateTable(result.Query); + result.RawSql = queryString; return result; } - private static string RefineQueryString(string queryString) - { - var lastCommaChar = queryString.LastIndexOf(','); - if(lastCommaChar != -1) - queryString = queryString.Remove(lastCommaChar,1); - return queryString; - } } } From f546968c3598b32509941017a5611b105a364173 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 17:04:13 +0330 Subject: [PATCH 20/33] Add DI to SqlKata Add Create Tables --- .../ICreateTableFormatFactoryProvider.cs | 9 ++++ .../Abstractions/ICreateTableQueryCompiler.cs | 3 +- .../ICreateTableQueryFillerProvider.cs | 9 ++++ .../DDLCompiler/Abstractions/IDDLCompiler.cs | 8 +-- .../Abstractions/ISqlCreateCommandProvider.cs | 9 ++++ .../Abstractions/ISqlCreateCommandUtil.cs | 2 + .../CreateTableCompiler.cs | 38 ++++++++++++++ .../GeneralCreateTableCompiler.cs | 50 ------------------- .../MySqlCreateCommandUtil.cs | 3 ++ .../OracleCreateCommandUtil.cs | 3 ++ .../PostgresqlCreateCommandUtil.cs | 3 ++ .../SqlServerCreateCommandUtil.cs | 3 ++ .../SqliteCreateCommandUtil.cs | 3 ++ .../Compilers/DDLCompiler/DDLCompiler.cs | 8 +-- .../CreateTableFormatFactoryProvider.cs | 22 ++++++++ .../CreateTableFormatFillerProvider.cs | 22 ++++++++ .../Providers/SqlCommandUtilProvider.cs | 22 ++++++++ QueryBuilder/KataDependencyInjection.cs | 28 +++++++++++ QueryBuilder/QueryBuilder.csproj | 1 + 19 files changed, 188 insertions(+), 58 deletions(-) create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableFormatFactoryProvider.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryFillerProvider.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandProvider.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableCompiler.cs delete mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFactoryProvider.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFillerProvider.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Providers/SqlCommandUtilProvider.cs create mode 100644 QueryBuilder/KataDependencyInjection.cs diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableFormatFactoryProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableFormatFactoryProvider.cs new file mode 100644 index 00000000..66b0cc60 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableFormatFactoryProvider.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableFormatFactoryProvider + { + ICreateQueryFormatFactory GetCreateQueryFormatFactory(DataSource dataSource); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs index 517125d1..7d23bf4f 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs @@ -1,11 +1,12 @@ using System.Collections.Generic; using System.Text; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface ICreateTableQueryCompiler { - string CompileCreateTable(Query query); + string CompileCreateTable(Query query,DataSource dataSource); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryFillerProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryFillerProvider.cs new file mode 100644 index 00000000..8bed4722 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryFillerProvider.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableQueryFillerProvider + { + ICreateQueryFormatFiller GetCreateQueryFormatFiller(DataSource dataSource); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs index ca6e55dc..107825c8 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -1,7 +1,9 @@ -namespace SqlKata.Compilers.DDLCompiler.Abstractions +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions { - public interface IDDLCompiler + internal interface IDDLCompiler { - SqlResult CompileCreateTable(Query query); + SqlResult CompileCreateTable(Query query,DataSource dataSource); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandProvider.cs new file mode 100644 index 00000000..08ec6fe0 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandProvider.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ISqlCreateCommandProvider + { + ISqlCreateCommandUtil GetSqlCreateCommandUtil(DataSource dataSource); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs index c7ac42dd..2470cd45 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs @@ -1,9 +1,11 @@ +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface ISqlCreateCommandUtil { + DataSource DataSource { get; } string AutoIncrementIdentityCommandGenerator(); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableCompiler.cs new file mode 100644 index 00000000..af3345a2 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableCompiler.cs @@ -0,0 +1,38 @@ +using System.Collections.Generic; +using System.Text; +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers +{ + internal class CreateTableCompiler : ICreateTableQueryCompiler + { + private readonly ICreateTableFormatFactoryProvider _createQueryFormatFactoryProvider; + private readonly ICreateTableQueryFillerProvider _createQueryFormatFillerProvider; + + public CreateTableCompiler(ICreateTableQueryFillerProvider createQueryFormatFillerProvider, ICreateTableFormatFactoryProvider createQueryFormatFactoryProvider) + { + _createQueryFormatFillerProvider = createQueryFormatFillerProvider; + _createQueryFormatFactoryProvider = createQueryFormatFactoryProvider; + } + + public string CompileCreateTable(Query query,DataSource dataSource) + { + var formatFactory = _createQueryFormatFactoryProvider.GetCreateQueryFormatFactory(dataSource); + var formatFiller = _createQueryFormatFillerProvider.GetCreateQueryFormatFiller(dataSource); + var queryFormat = formatFactory.CreateTableFormat(); + var queryString = formatFiller.FillQueryFormat(queryFormat,query); + return RefineQueryString(queryString); + } + + private static string RefineQueryString(string queryString) + { + var lastCommaChar = queryString.LastIndexOf(','); + if(lastCommaChar != -1) + queryString = queryString.Remove(lastCommaChar,1); + return queryString; + } + + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs deleted file mode 100644 index 49cf21ce..00000000 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs +++ /dev/null @@ -1,50 +0,0 @@ -using System.Text; -using SqlKata.Clauses; -using SqlKata.Compilers.DDLCompiler.Abstractions; - -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers -{ - internal class GeneralCreateTableCompiler : ICreateTableQueryCompiler - { - private readonly ISqlCreateCommandUtil _sqlCommandUtil; - private readonly IColumnCompiler _columnCompiler; - private readonly IPrimaryKeyCompiler _primaryKeyCompiler; - private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; - - public GeneralCreateTableCompiler(ISqlCreateCommandUtil sqlCommandUtil, IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) - { - _sqlCommandUtil = sqlCommandUtil; - _columnCompiler = columnCompiler; - _primaryKeyCompiler = primaryKeyCompiler; - _uniqueConstraintCompiler = uniqueConstraintCompiler; - } - - public string CompileCreateTable(Query query) - { - /*var createTableColumnClauses = query.GetComponents("CreateTableColumn"); - var tableName = query.GetOneComponent("from").Table; - var tableType = query.GetOneComponent("TableType").TableType; - - var createTableString = _sqlCommandUtil.CreateTableCommandGenerator(tableType, tableName); - var queryString = new StringBuilder(createTableString); - queryString.Append("(\n"); - _columnCompiler.CompileCreateTableColumns(queryString,createTableColumnClauses); - _primaryKeyCompiler.CompilePrimaryKey(queryString,createTableColumnClauses); - _uniqueConstraintCompiler.CompileUniqueConstraints(queryString,createTableColumnClauses); - queryString.Append(")\n");*/ - - /* - return RefineQueryString(queryString.ToString());*/ - return null; - } - - private static string RefineQueryString(string queryString) - { - var lastCommaChar = queryString.LastIndexOf(','); - if(lastCommaChar != -1) - queryString = queryString.Remove(lastCommaChar,1); - return queryString; - } - - } -} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs index 437592ed..7231cce3 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs @@ -1,10 +1,13 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class MySqlCreateCommandUtil : ISqlCreateCommandUtil { + public DataSource DataSource { get; } = DataSource.MySql; + public string AutoIncrementIdentityCommandGenerator() { return "AUTO_INCREMENT "; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs index 8fbfabe0..1bf63862 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs @@ -1,10 +1,13 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class OracleCreateCommandUtil : ISqlCreateCommandUtil { + public DataSource DataSource { get; } = DataSource.Oracle; + public string AutoIncrementIdentityCommandGenerator() { return "GENERATED ALWAYS AS IDENTITY "; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs index 1ad43674..e53bdc45 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs @@ -1,10 +1,13 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class PostgresqlCreateCommandUtil : ISqlCreateCommandUtil { + public DataSource DataSource { get; } = DataSource.Postgresql; + public string AutoIncrementIdentityCommandGenerator() { return ""; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs index 5b972015..529b2887 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs @@ -1,10 +1,13 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class SqlServerCreateCommandUtil : ISqlCreateCommandUtil { + public DataSource DataSource { get; } = DataSource.SqlServer; + public string AutoIncrementIdentityCommandGenerator() { return "IDENTITY(1,1) "; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs index 00771a0c..456470a5 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs @@ -1,10 +1,13 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { internal class SqliteCreateCommandUtil : ISqlCreateCommandUtil { + public DataSource DataSource { get; } = DataSource.Sqlite; + public string AutoIncrementIdentityCommandGenerator() { return "AUTOINCREMENT "; diff --git a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs index 84bda2bf..a5ce4b8b 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -1,9 +1,9 @@ -using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers.DDLCompiler { - internal class DDLCompiler + internal class DDLCompiler : IDDLCompiler { private readonly ICreateTableQueryCompiler _createTableQueryCompiler; @@ -13,13 +13,13 @@ public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler) } - internal SqlResult CompileCreateTable(Query query) + public SqlResult CompileCreateTable(Query query,DataSource dataSource) { var result = new SqlResult() { Query = query.Clone(), }; - var queryString = _createTableQueryCompiler.CompileCreateTable(result.Query); + var queryString = _createTableQueryCompiler.CompileCreateTable(result.Query,dataSource); result.RawSql = queryString; return result; } diff --git a/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFactoryProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFactoryProvider.cs new file mode 100644 index 00000000..2b4166de --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFactoryProvider.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; +using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Providers +{ + internal class CreateTableFormatFactoryProvider : ICreateTableFormatFactoryProvider + { + private readonly Dictionary _createQueryFormatFactoriesByDataSource; + + public CreateTableFormatFactoryProvider(IEnumerable createQueryFormatFactories) + { + _createQueryFormatFactoriesByDataSource = createQueryFormatFactories.ToDictionary(x => x.DataSource); + } + + public ICreateQueryFormatFactory GetCreateQueryFormatFactory(DataSource dataSource) + { + return _createQueryFormatFactoriesByDataSource[dataSource]; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFillerProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFillerProvider.cs new file mode 100644 index 00000000..50c3d405 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Providers/CreateTableFormatFillerProvider.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; +using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Providers +{ + internal class CreateTableFormatFillerProvider : ICreateTableQueryFillerProvider + { + private readonly Dictionary _createQueryFormatFillersByDataSource; + + public CreateTableFormatFillerProvider(IEnumerable createQueryFormatFillers) + { + _createQueryFormatFillersByDataSource = createQueryFormatFillers.ToDictionary(x => x.DataSource); + } + + public ICreateQueryFormatFiller GetCreateQueryFormatFiller(DataSource dataSource) + { + return _createQueryFormatFillersByDataSource[dataSource]; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Providers/SqlCommandUtilProvider.cs b/QueryBuilder/Compilers/DDLCompiler/Providers/SqlCommandUtilProvider.cs new file mode 100644 index 00000000..218d8adc --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Providers/SqlCommandUtilProvider.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; +using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Providers +{ + internal class SqlCommandUtilProvider : ISqlCreateCommandProvider + { + private readonly Dictionary _sqlCreateCommandUtilsByDataSource; + public SqlCommandUtilProvider(IEnumerable sqlCreateCommandUtils) + { + _sqlCreateCommandUtilsByDataSource = sqlCreateCommandUtils.ToDictionary(x => x.DataSource); + } + + + public ISqlCreateCommandUtil GetSqlCreateCommandUtil(DataSource dataSource) + { + return _sqlCreateCommandUtilsByDataSource[dataSource]; + } + } +} diff --git a/QueryBuilder/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs new file mode 100644 index 00000000..7a348e85 --- /dev/null +++ b/QueryBuilder/KataDependencyInjection.cs @@ -0,0 +1,28 @@ +using Microsoft.Extensions.DependencyInjection; +using SqlKata.Compilers.DDLCompiler; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.PrimaryKeyCompilers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers; +using SqlKata.Compilers.DDLCompiler.Providers; + +namespace SqlKata +{ + public static class KataDependencyInjection + { + public static IServiceCollection AddKataServices(this IServiceCollection services) + { + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + return services; + } + } +} diff --git a/QueryBuilder/QueryBuilder.csproj b/QueryBuilder/QueryBuilder.csproj index 0129e174..8f17df66 100755 --- a/QueryBuilder/QueryBuilder.csproj +++ b/QueryBuilder/QueryBuilder.csproj @@ -34,5 +34,6 @@ + From f6e3cdcf2fd69df904cf2fb56ba6a87630821711 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 17:17:58 +0330 Subject: [PATCH 21/33] change the versions --- Program/Program.cs | 14 ++++---------- Program/Program.csproj | 2 +- QueryBuilder/KataDependencyInjection.cs | 19 +++++++++++++++++++ 3 files changed, 24 insertions(+), 11 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index 9bb19a6a..38fb5b06 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -1,18 +1,12 @@ using System; using System.Collections.Generic; -using SqlKata; -using SqlKata.Compilers; -using SqlKata.Execution; using System.Data.SqlClient; -using System.Threading.Tasks; -using System.Linq; -using Newtonsoft.Json; -using Npgsql; -using System.Data; -using Dapper; using System.Data.SQLite; -using static SqlKata.Expressions; using System.IO; +using Newtonsoft.Json; +using SqlKata; +using SqlKata.Compilers; +using SqlKata.Execution; using SqlKata.Contract.CreateTable; using SqlKata.DbTypes.DbColumn; using SqlKata.DbTypes.Enums; diff --git a/Program/Program.csproj b/Program/Program.csproj index 6341ecef..99a09bdc 100644 --- a/Program/Program.csproj +++ b/Program/Program.csproj @@ -15,7 +15,7 @@ Exe false - netcoreapp2.0 + net6.0 diff --git a/QueryBuilder/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs index 7a348e85..834b5ef5 100644 --- a/QueryBuilder/KataDependencyInjection.cs +++ b/QueryBuilder/KataDependencyInjection.cs @@ -3,7 +3,10 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.PrimaryKeyCompilers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers; using SqlKata.Compilers.DDLCompiler.Providers; @@ -22,6 +25,22 @@ public static IServiceCollection AddKataServices(this IServiceCollection service services.AddSingleton(); services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + return services; } } From 0a1b8b5819f0dd43d7125f16a8e4c0441836b4b4 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 17:29:51 +0330 Subject: [PATCH 22/33] di managing --- Program/Program.cs | 117 ++++--------------------------- Program/Program.csproj | 1 + QueryBuilder/QueryBuilder.csproj | 5 +- 3 files changed, 20 insertions(+), 103 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index 38fb5b06..2733369a 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -1,12 +1,8 @@ using System; using System.Collections.Generic; -using System.Data.SqlClient; -using System.Data.SQLite; -using System.IO; -using Newtonsoft.Json; +using Microsoft.Extensions.DependencyInjection; using SqlKata; using SqlKata.Compilers; -using SqlKata.Execution; using SqlKata.Contract.CreateTable; using SqlKata.DbTypes.DbColumn; using SqlKata.DbTypes.Enums; @@ -15,128 +11,45 @@ namespace Program { class Program { - private class Loan + static void Main(string[] args) { - public string Id { get; set; } - public string Name { get; set; } - public List Installments { get; set; } = new List(); - } + var serviceCollection = new ServiceCollection(); + var provider = serviceCollection.BuildServiceProvider(); - private class Installment - { - public string Id { get; set; } - public string LoanId { get; set; } - public int DaysCount { get; set; } - } - static void Main(string[] args) - { var query = new Query("Users").CreateTable(new List() { new TableColumnDefenitionDto() { - ColumnName= "id", + ColumnName = "id", ColumnDbType = new PostgresqlDBColumn() { PostgresqlDbType = PostgresqlDbType.Integer }, - IsAutoIncrement=true, - IsNullable=false, - IsPrimaryKey=true, - IsUnique=false, + IsAutoIncrement = true, + IsNullable = false, + IsPrimaryKey = true, + IsUnique = false, }, new TableColumnDefenitionDto() { - ColumnName= "FullName", + ColumnName = "FullName", ColumnDbType = new PostgresqlDBColumn() { PostgresqlDbType = PostgresqlDbType.Character_varying, Length = 30 }, - IsAutoIncrement=false, - IsNullable=false, - IsPrimaryKey=false, - IsUnique=true, + IsAutoIncrement = false, + IsNullable = false, + IsPrimaryKey = false, + IsUnique = true, } - },TableType.Temporary); + }, TableType.Temporary); var compiler = new PostgresCompiler(); Console.WriteLine(compiler.Compile(query)); -/* using (var db = SqlLiteQueryFactory()) - { - var query = db.Query("accounts") - .Where("balance", ">", 0) - .GroupBy("balance") - .Limit(10); - - var accounts = query.Clone().Get(); - Console.WriteLine(JsonConvert.SerializeObject(accounts, Formatting.Indented)); - - var exists = query.Clone().Exists(); - Console.WriteLine(exists); - }*/ - } - - private static void log(Compiler compiler, Query query) - { - var compiled = compiler.Compile(query); - Console.WriteLine(compiled.ToString()); - Console.WriteLine(JsonConvert.SerializeObject(compiled.Bindings)); - } - - private static QueryFactory SqlLiteQueryFactory() - { - var compiler = new SqliteCompiler(); - - var connection = new SQLiteConnection("Data Source=Demo.db"); - - var db = new QueryFactory(connection, compiler); - - db.Logger = result => - { - Console.WriteLine(result.ToString()); - }; - - if (!File.Exists("Demo.db")) - { - Console.WriteLine("db not exists creating db"); - - SQLiteConnection.CreateFile("Demo.db"); - - db.Statement("create table accounts(id integer primary key autoincrement, name varchar, currency_id varchar, balance decimal, created_at datetime);"); - for (var i = 0; i < 10; i++) - { - db.Statement("insert into accounts(name, currency_id, balance, created_at) values(@name, @currency, @balance, @date)", new - { - name = $"Account {i}", - currency = "USD", - balance = 100 * i * 1.1, - date = DateTime.UtcNow, - }); - } - - } - return db; } - - private static QueryFactory SqlServerQueryFactory() - { - var compiler = new PostgresCompiler(); - var connection = new SqlConnection( - "Server=tcp:localhost,1433;Initial Catalog=Lite;User ID=sa;Password=P@ssw0rd" - ); - - var db = new QueryFactory(connection, compiler); - - db.Logger = result => - { - Console.WriteLine(result.ToString()); - }; - - return db; - } - } } diff --git a/Program/Program.csproj b/Program/Program.csproj index 99a09bdc..2e44c542 100644 --- a/Program/Program.csproj +++ b/Program/Program.csproj @@ -10,6 +10,7 @@ + diff --git a/QueryBuilder/QueryBuilder.csproj b/QueryBuilder/QueryBuilder.csproj index 8f17df66..78ecd5b6 100755 --- a/QueryBuilder/QueryBuilder.csproj +++ b/QueryBuilder/QueryBuilder.csproj @@ -34,6 +34,9 @@ - + + + + From e2e3ce4093e59ddafb1ba7181c5e5948a3db7d23 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 19:29:32 +0330 Subject: [PATCH 23/33] Create Table is now under test --- Program/Program.cs | 8 +++++-- .../Abstractions/ICompilerFactory.cs | 10 +++++++++ .../Abstractions/ICompilerProvider.cs | 9 ++++++++ QueryBuilder/Compilers/Compiler.cs | 8 +++---- .../DDLCompiler/Abstractions/IDDLCompiler.cs | 2 +- QueryBuilder/Compilers/Enums/DataSource.cs | 2 +- QueryBuilder/Compilers/FirebirdCompiler.cs | 8 +++++++ QueryBuilder/Compilers/MySqlCompiler.cs | 12 +++++++++- QueryBuilder/Compilers/OracleCompiler.cs | 12 ++++++++-- QueryBuilder/Compilers/PostgresCompiler.cs | 10 ++++++++- .../Compilers/Providers/CompilerProvider.cs | 21 ++++++++++++++++++ .../Factories/FirebirdCompilerFactory.cs | 22 +++++++++++++++++++ .../Factories/MySqlCompilerFactory.cs | 22 +++++++++++++++++++ .../Factories/OracleCompilerFactory.cs | 22 +++++++++++++++++++ .../Factories/PostgresCompilerFactory.cs | 22 +++++++++++++++++++ .../Factories/SqlServerCompilerFactory.cs | 22 +++++++++++++++++++ .../Factories/SqliteCompilerFactory.cs | 22 +++++++++++++++++++ QueryBuilder/Compilers/SqlServerCompiler.cs | 10 ++++++++- QueryBuilder/Compilers/SqliteCompiler.cs | 13 +++++++++++ QueryBuilder/KataDependencyInjection.cs | 11 ++++++++++ QueryBuilder/QueryBuilder.csproj | 3 --- 21 files changed, 255 insertions(+), 16 deletions(-) create mode 100644 QueryBuilder/Compilers/Abstractions/ICompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Abstractions/ICompilerProvider.cs create mode 100644 QueryBuilder/Compilers/Providers/CompilerProvider.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/FirebirdCompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/MySqlCompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/OracleCompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/PostgresCompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/SqlServerCompilerFactory.cs create mode 100644 QueryBuilder/Compilers/Providers/Factories/SqliteCompilerFactory.cs diff --git a/Program/Program.cs b/Program/Program.cs index 2733369a..f2dd77f5 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -3,6 +3,8 @@ using Microsoft.Extensions.DependencyInjection; using SqlKata; using SqlKata.Compilers; +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; using SqlKata.DbTypes.DbColumn; using SqlKata.DbTypes.Enums; @@ -14,8 +16,10 @@ class Program static void Main(string[] args) { var serviceCollection = new ServiceCollection(); + serviceCollection.AddKataServices(); var provider = serviceCollection.BuildServiceProvider(); - + var compilerProvider = provider.GetRequiredService(); + var compiler = compilerProvider.CreateCompiler(DataSource.Postgresql); var query = new Query("Users").CreateTable(new List() { @@ -45,7 +49,7 @@ static void Main(string[] args) IsUnique = true, } }, TableType.Temporary); - var compiler = new PostgresCompiler(); + Console.WriteLine(compiler.Compile(query)); diff --git a/QueryBuilder/Compilers/Abstractions/ICompilerFactory.cs b/QueryBuilder/Compilers/Abstractions/ICompilerFactory.cs new file mode 100644 index 00000000..6e879cd9 --- /dev/null +++ b/QueryBuilder/Compilers/Abstractions/ICompilerFactory.cs @@ -0,0 +1,10 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Abstractions +{ + internal interface ICompilerFactory + { + DataSource DataSource { get; } + Compiler CreateCompiler(); + } +} diff --git a/QueryBuilder/Compilers/Abstractions/ICompilerProvider.cs b/QueryBuilder/Compilers/Abstractions/ICompilerProvider.cs new file mode 100644 index 00000000..3dd92d90 --- /dev/null +++ b/QueryBuilder/Compilers/Abstractions/ICompilerProvider.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Abstractions +{ + public interface ICompilerProvider + { + Compiler CreateCompiler(DataSource dataSource); + } +} diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index ceaff3a2..bd107ae2 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using System.Text; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers { @@ -17,7 +18,6 @@ public abstract partial class Compiler protected virtual string LastId { get; set; } = ""; protected virtual string EscapeCharacter { get; set; } = "\\"; - protected virtual string SingleInsertStartClause { get; set; } = "INSERT INTO"; protected virtual string MultiInsertStartClause { get; set; } = "INSERT INTO"; @@ -32,13 +32,13 @@ protected Compiler() /// /// Whether the compiler supports the `SELECT ... FILTER` syntax /// - /// + /// public virtual bool SupportsFilterClause { get; set; } = false; /// /// If true the compiler will remove the SELECT clause for the query used inside WHERE EXISTS /// - /// + /// public virtual bool OmitSelectInsideExists { get; set; } = true; protected virtual string SingleRowDummyTableName { get => null; } @@ -305,7 +305,7 @@ protected virtual SqlResult CompileDeleteQuery(Query query) } else { - // check if we have alias + // check if we have alias if (fromClause is FromClause && !string.IsNullOrEmpty(fromClause.Alias)) { ctx.RawSql = $"DELETE {Wrap(fromClause.Alias)} FROM {table} {joins}{where}"; diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs index 107825c8..4ea02379 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -2,7 +2,7 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions { - internal interface IDDLCompiler + public interface IDDLCompiler { SqlResult CompileCreateTable(Query query,DataSource dataSource); } diff --git a/QueryBuilder/Compilers/Enums/DataSource.cs b/QueryBuilder/Compilers/Enums/DataSource.cs index 6ca40616..cf55fd50 100644 --- a/QueryBuilder/Compilers/Enums/DataSource.cs +++ b/QueryBuilder/Compilers/Enums/DataSource.cs @@ -1,6 +1,6 @@ namespace SqlKata.Compilers.Enums { - internal enum DataSource + public enum DataSource { SqlServer, Oracle, diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs index 204ccb58..c29449dc 100644 --- a/QueryBuilder/Compilers/FirebirdCompiler.cs +++ b/QueryBuilder/Compilers/FirebirdCompiler.cs @@ -1,13 +1,21 @@ using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers { public class FirebirdCompiler : Compiler { + private readonly IDDLCompiler _ddlCompiler; + public FirebirdCompiler(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + public FirebirdCompiler() { + } public override string EngineCode { get; } = EngineCodes.Firebird; diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs index 96eec8fa..59f2f6b2 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -1,13 +1,23 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + namespace SqlKata.Compilers { public class MySqlCompiler : Compiler { + private readonly IDDLCompiler _ddlCompiler; + public MySqlCompiler(IDDLCompiler ddlCompiler) : this() + { + _ddlCompiler = ddlCompiler; + } + public MySqlCompiler() { OpeningIdentifier = ClosingIdentifier = "`"; LastId = "SELECT last_insert_id() as Id"; } + public override string EngineCode { get; } = EngineCodes.MySql; public override string CompileLimit(SqlResult ctx) @@ -48,7 +58,7 @@ public override string CompileLimit(SqlResult ctx) protected override SqlResult CompileCreateTable(Query query) { - return null; + return _ddlCompiler.CompileCreateTable(query,DataSource.MySql); } } } diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 124bc1ec..5477976a 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,12 +1,20 @@ using System; using System.Collections.Generic; using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class OracleCompiler : Compiler { - private const string CreateTableCondition = "ON COMMIT PRESERVE ROWS"; + private readonly IDDLCompiler _ddlCompiler; + public OracleCompiler(IDDLCompiler ddlCompiler) : this() + { + _ddlCompiler = ddlCompiler; + + } + public OracleCompiler() { ColumnAsKeyword = ""; @@ -174,7 +182,7 @@ protected override SqlResult CompileRemainingInsertClauses( protected override SqlResult CompileCreateTable(Query query) { - return null; + return _ddlCompiler.CompileCreateTable(query,DataSource.Oracle); } diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs index 4adeedbd..c1b73bf9 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -1,10 +1,18 @@ using System; using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class PostgresCompiler : Compiler { + private readonly IDDLCompiler _ddlCompiler; + public PostgresCompiler(IDDLCompiler ddlCompiler) : this() + { + _ddlCompiler = ddlCompiler; + } + public PostgresCompiler() { LastId = "SELECT lastval() AS id"; @@ -98,7 +106,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond protected override SqlResult CompileCreateTable(Query query) { - return null; + return _ddlCompiler.CompileCreateTable(query,DataSource.Postgresql); } } } diff --git a/QueryBuilder/Compilers/Providers/CompilerProvider.cs b/QueryBuilder/Compilers/Providers/CompilerProvider.cs new file mode 100644 index 00000000..c2d4b758 --- /dev/null +++ b/QueryBuilder/Compilers/Providers/CompilerProvider.cs @@ -0,0 +1,21 @@ +using System.Collections.Generic; +using System.Linq; +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers +{ + internal class CompilerProvider : ICompilerProvider + { + private readonly Dictionary _compilerFactoriesByDataSource; + + public CompilerProvider(IEnumerable compilerFactories) + { + _compilerFactoriesByDataSource = compilerFactories.ToDictionary(x => x.DataSource); + } + public Compiler CreateCompiler(DataSource dataSource) + { + return _compilerFactoriesByDataSource[dataSource].CreateCompiler(); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/FirebirdCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/FirebirdCompilerFactory.cs new file mode 100644 index 00000000..8e25e1e7 --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/FirebirdCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class FirebirdCompilerFactory: ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public FirebirdCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.Firebird; + public Compiler CreateCompiler() + { + return new FirebirdCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/MySqlCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/MySqlCompilerFactory.cs new file mode 100644 index 00000000..ef51ed4e --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/MySqlCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class MySqlCompilerFactory : ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public MySqlCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.MySql; + public Compiler CreateCompiler() + { + return new MySqlCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/OracleCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/OracleCompilerFactory.cs new file mode 100644 index 00000000..9c408d8f --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/OracleCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class OracleCompilerFactory: ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public OracleCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.Oracle; + public Compiler CreateCompiler() + { + return new OracleCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/PostgresCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/PostgresCompilerFactory.cs new file mode 100644 index 00000000..81cf34bc --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/PostgresCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class PostgresCompilerFactory : ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public PostgresCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.Postgresql; + public Compiler CreateCompiler() + { + return new PostgresCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/SqlServerCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/SqlServerCompilerFactory.cs new file mode 100644 index 00000000..539da273 --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/SqlServerCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class SqlServerCompilerFactory : ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public SqlServerCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.SqlServer; + public Compiler CreateCompiler() + { + return new SqlServerCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/Providers/Factories/SqliteCompilerFactory.cs b/QueryBuilder/Compilers/Providers/Factories/SqliteCompilerFactory.cs new file mode 100644 index 00000000..07000159 --- /dev/null +++ b/QueryBuilder/Compilers/Providers/Factories/SqliteCompilerFactory.cs @@ -0,0 +1,22 @@ +using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.Providers.Factories +{ + public class SqliteCompilerFactory : ICompilerFactory + { + private readonly IDDLCompiler _ddlCompiler; + + public SqliteCompilerFactory(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public DataSource DataSource { get; } = DataSource.Sqlite; + public Compiler CreateCompiler() + { + return new SqliteCompiler(_ddlCompiler); + } + } +} diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 720feb8e..6674b27c 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,9 +1,17 @@ using System.Linq; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class SqlServerCompiler : Compiler { + private readonly IDDLCompiler _ddlCompiler; + public SqlServerCompiler(IDDLCompiler ddlCompiler) : this() + { + _ddlCompiler = ddlCompiler; + } + public SqlServerCompiler() { OpeningIdentifier = "["; @@ -189,7 +197,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) protected override SqlResult CompileCreateTable(Query query) { - return null; + return _ddlCompiler.CompileCreateTable(query,DataSource.SqlServer); } } } diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs index 6b8d61c4..0f53d1cd 100644 --- a/QueryBuilder/Compilers/SqliteCompiler.cs +++ b/QueryBuilder/Compilers/SqliteCompiler.cs @@ -1,9 +1,22 @@ using System.Collections.Generic; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers { public class SqliteCompiler : Compiler { + private readonly IDDLCompiler _ddlCompiler; + + public SqliteCompiler(IDDLCompiler ddlCompiler) + { + _ddlCompiler = ddlCompiler; + } + + public SqliteCompiler() + { + + } + public override string EngineCode { get; } = EngineCodes.Sqlite; protected override string OpeningIdentifier { get; set; } = "\""; protected override string ClosingIdentifier { get; set; } = "\""; diff --git a/QueryBuilder/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs index 834b5ef5..7ceb588b 100644 --- a/QueryBuilder/KataDependencyInjection.cs +++ b/QueryBuilder/KataDependencyInjection.cs @@ -1,4 +1,5 @@ using Microsoft.Extensions.DependencyInjection; +using SqlKata.Compilers.Abstractions; using SqlKata.Compilers.DDLCompiler; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers; @@ -9,6 +10,8 @@ using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers; using SqlKata.Compilers.DDLCompiler.Providers; +using SqlKata.Compilers.Providers; +using SqlKata.Compilers.Providers.Factories; namespace SqlKata { @@ -40,6 +43,14 @@ public static IServiceCollection AddKataServices(this IServiceCollection service services.AddSingleton(); services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + services.AddSingleton(); return services; } diff --git a/QueryBuilder/QueryBuilder.csproj b/QueryBuilder/QueryBuilder.csproj index 78ecd5b6..e0a2453c 100755 --- a/QueryBuilder/QueryBuilder.csproj +++ b/QueryBuilder/QueryBuilder.csproj @@ -36,7 +36,4 @@ - - - From 907b2ca89139617a6e928ae0e673b78ba280475b Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 19:43:48 +0330 Subject: [PATCH 24/33] bug fix for oracle bug fix for mysql and postgresql --- Program/Program.cs | 14 +++++++------- .../Factories/MySqlCreateTableFormatFactory.cs | 2 +- .../PostgresqlCreateTableFormatFactory.cs | 2 +- .../Fillers/OracleCreateQueryFormatFiller.cs | 8 +++++++- .../DbTableSpecific/OracleDbTableExtensions.cs | 2 +- 5 files changed, 17 insertions(+), 11 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index f2dd77f5..84c9eb0a 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -19,28 +19,28 @@ static void Main(string[] args) serviceCollection.AddKataServices(); var provider = serviceCollection.BuildServiceProvider(); var compilerProvider = provider.GetRequiredService(); - var compiler = compilerProvider.CreateCompiler(DataSource.Postgresql); + var compiler = compilerProvider.CreateCompiler(DataSource.Oracle); var query = new Query("Users").CreateTable(new List() { - new TableColumnDefenitionDto() + new() { ColumnName = "id", - ColumnDbType = new PostgresqlDBColumn() + ColumnDbType = new OracleDBColumn() { - PostgresqlDbType = PostgresqlDbType.Integer + OracleDbType = OracleDbType.Int32 }, IsAutoIncrement = true, IsNullable = false, IsPrimaryKey = true, IsUnique = false, }, - new TableColumnDefenitionDto() + new() { ColumnName = "FullName", - ColumnDbType = new PostgresqlDBColumn() + ColumnDbType = new OracleDBColumn() { - PostgresqlDbType = PostgresqlDbType.Character_varying, + OracleDbType = OracleDbType.Varchar2, Length = 30 }, IsAutoIncrement = false, diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs index 2650510d..303d5331 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs @@ -9,7 +9,7 @@ internal class MySqlCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE {0} TABLE {1} ( - {2}, + {2} {3} {4} )"; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs index deb3ea80..84f94fd1 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs @@ -9,7 +9,7 @@ internal class PostgresqlCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE {0} TABLE {1} ( - {2}, + {2} {3} {4} )"; diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs index b034d222..2d4c4a2a 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs @@ -2,6 +2,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; +using SqlKata.Contract.CreateTable.DbTableSpecific; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers { @@ -25,6 +26,10 @@ public string FillQueryFormat(string queryFormat,Query query) var tableName = query.GetOneComponent("from").Table; var tableType = query.GetOneComponent("TableType").TableType; var tempString = tableType == TableType.Temporary ? "GLOBAL TEMPORARY" : ""; + + var tableExtensions = (OracleDbTableExtensions)query.GetOneComponent("CreateTableExtension")?.CreateDbTableExtension; + var onCommitBehaviour = tableExtensions != null && tableType == TableType.Temporary && tableExtensions.OnCommitPreserveRows ? "on commit preserve rows" : "on commit delete rows" ; + string hint = ""; return string.Format(queryFormat, tempString, @@ -32,7 +37,8 @@ public string FillQueryFormat(string queryFormat,Query query) tableName, _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), - _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses), + onCommitBehaviour ); } } diff --git a/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs index adf45e89..cfca17f7 100644 --- a/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs +++ b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs @@ -1,6 +1,6 @@ namespace SqlKata.Contract.CreateTable.DbTableSpecific { - public class OracleDbTableExtensions + public class OracleDbTableExtensions : CreateDbTableExtension { public bool OnCommitPreserveRows { get; set; } } From 4a99fe001c77b03589efd9245cd9fe33bf3599d3 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Mon, 3 Jul 2023 19:44:57 +0330 Subject: [PATCH 25/33] on commit preserve rows was added success fully for oracle create table --- Program/Program.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Program/Program.cs b/Program/Program.cs index 84c9eb0a..585c5746 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -6,6 +6,7 @@ using SqlKata.Compilers.Abstractions; using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; +using SqlKata.Contract.CreateTable.DbTableSpecific; using SqlKata.DbTypes.DbColumn; using SqlKata.DbTypes.Enums; @@ -48,7 +49,7 @@ static void Main(string[] args) IsPrimaryKey = false, IsUnique = true, } - }, TableType.Temporary); + }, TableType.Temporary,new OracleDbTableExtensions(){OnCommitPreserveRows = true}); Console.WriteLine(compiler.Compile(query)); From acdccff8e084c75951f3e10c8dfe7ef85ebf7dc3 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Tue, 4 Jul 2023 12:00:10 +0330 Subject: [PATCH 26/33] add hint and collation for table creation --- .../CreateTable/DbTableSpecific/OracleDbTableExtensions.cs | 1 + QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs index cfca17f7..1291b090 100644 --- a/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs +++ b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs @@ -3,5 +3,6 @@ public class OracleDbTableExtensions : CreateDbTableExtension { public bool OnCommitPreserveRows { get; set; } + public string hint { get; set; } } } diff --git a/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs index 38e3315a..a560fe12 100644 --- a/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs +++ b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs @@ -4,8 +4,9 @@ namespace SqlKata.DbTypes.DbColumn { public abstract class BaseDBColumn { - public int? Length { get; set; } + public int? Length { get; set; } public int? Precision { get; set; } + public string Collation { get; set; } internal abstract string GetDBType(); protected void AddLengthAndPrecisionToType(StringBuilder stringBuilder) From dd7cbd313263cab2dffc4777413aaa4cb994ee29 Mon Sep 17 00:00:00 2001 From: Reza Mehtari Date: Tue, 4 Jul 2023 12:13:24 +0330 Subject: [PATCH 27/33] add collate to CreateTableColumn --- Program/Program.cs | 2 +- QueryBuilder/Clauses/ColumnClause.cs | 4 +++- .../ColumnCompilers/ColumnCompiler.cs | 11 ++++++----- ...mnDefenitionDto.cs => TableColumnDefinitionDto.cs} | 3 ++- QueryBuilder/Query.CreateTable.cs | 5 +++-- 5 files changed, 15 insertions(+), 10 deletions(-) rename QueryBuilder/Contract/CreateTable/{TableColumnDefenitionDto.cs => TableColumnDefinitionDto.cs} (83%) diff --git a/Program/Program.cs b/Program/Program.cs index 585c5746..7d22285a 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -22,7 +22,7 @@ static void Main(string[] args) var compilerProvider = provider.GetRequiredService(); var compiler = compilerProvider.CreateCompiler(DataSource.Oracle); - var query = new Query("Users").CreateTable(new List() + var query = new Query("Users").CreateTable(new List() { new() { diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index 8864efb9..c76b789b 100644 --- a/QueryBuilder/Clauses/ColumnClause.cs +++ b/QueryBuilder/Clauses/ColumnClause.cs @@ -41,6 +41,7 @@ public class CreateTableColumn : AbstractClause public bool IsUnique { get; set; } public bool IsIdentity { get; set; } public bool IsAutoIncrement { get; set; } + public string Collate { get; set; } public override AbstractClause Clone() { return new CreateTableColumn @@ -53,6 +54,7 @@ public override AbstractClause Clone() IsUnique= IsUnique, IsIdentity= IsIdentity, IsNullable= IsNullable, + Collate = Collate }; } } @@ -114,7 +116,7 @@ public override AbstractClause Clone() public class AggregatedColumn : AbstractColumn { /// - /// Gets or sets the a query that used to filter the data, + /// Gets or sets the a query that used to filter the data, /// the compiler will consider only the `Where` clause. /// /// diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs index cda7fb23..807d648b 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs @@ -22,15 +22,16 @@ public string CompileCreateTableColumns(List createTableColum { throw new AutoIncrementOrIdentityExceededException("table can not have more than one auto increment or identity column"); } - foreach (var columnCluase in createTableColumnClauses) + foreach (var columnClause in createTableColumnClauses) { - var nullOrNot = columnCluase.IsNullable ? "NULL " : "NOT NULL "; - if (columnCluase.IsIdentity || columnCluase.IsAutoIncrement) + var nullOrNot = columnClause.IsNullable ? "NULL " : "NOT NULL "; + var collate = columnClause.Collate == null ? "" : $"Collate {columnClause.Collate}"; + if (columnClause.IsIdentity || columnClause.IsAutoIncrement) { - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); + queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); continue; } - queryString.Append($"{columnCluase.ColumnName} {columnCluase.ColumnDbType.GetDBType()} {nullOrNot},\n"); + queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {nullOrNot},\n"); } return queryString.ToString(); diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs similarity index 83% rename from QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs rename to QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs index 79ac645d..192ef226 100644 --- a/QueryBuilder/Contract/CreateTable/TableColumnDefenitionDto.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs @@ -2,7 +2,7 @@ namespace SqlKata.Contract.CreateTable { - public class TableColumnDefenitionDto + public class TableColumnDefinitionDto { public string ColumnName { get; set; } public BaseDBColumn ColumnDbType { get; set; } @@ -11,5 +11,6 @@ public class TableColumnDefenitionDto public bool IsUnique { get; set; } public bool IsIdentity { get; set; } public bool IsAutoIncrement { get; set; } + public string Collate { get; set; } } } diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index fa6e2897..4bb9a50f 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -8,7 +8,7 @@ namespace SqlKata { public partial class Query { - public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent,CreateDbTableExtension createDbTableExtension = null) + public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent,CreateDbTableExtension createDbTableExtension = null) { Method = "CreateTable"; @@ -29,7 +29,8 @@ public Query CreateTable(IEnumerable columns,TableType IsUnique = column.IsUnique, IsPrimaryKey = column.IsPrimaryKey, IsAutoIncrement = column.IsAutoIncrement, - IsIdentity = column.IsIdentity + IsIdentity = column.IsIdentity, + Collate = column.Collate }); }); From e4706a7fe5081814f34f4d0f1783a05d87562256 Mon Sep 17 00:00:00 2001 From: Reza Mehtari Date: Tue, 4 Jul 2023 14:03:06 +0330 Subject: [PATCH 28/33] create CreateTableAsClause.cs --- QueryBuilder/Clauses/CreateTableAsClause.cs | 14 +++++++++++ .../InvalidQueryMethodException.cs | 24 +++++++++++++++++++ QueryBuilder/Query.CreateTable.cs | 22 +++++++++++++++++ 3 files changed, 60 insertions(+) create mode 100644 QueryBuilder/Clauses/CreateTableAsClause.cs create mode 100644 QueryBuilder/Exceptions/CreateTableQuery/InvalidQueryMethodException.cs diff --git a/QueryBuilder/Clauses/CreateTableAsClause.cs b/QueryBuilder/Clauses/CreateTableAsClause.cs new file mode 100644 index 00000000..07ee3d42 --- /dev/null +++ b/QueryBuilder/Clauses/CreateTableAsClause.cs @@ -0,0 +1,14 @@ +namespace SqlKata.Clauses +{ + public class CreateTableAsClause : AbstractClause + { + public Query SelectQuery { get; set; } + public override AbstractClause Clone() + { + return new CreateTableAsClause + { + SelectQuery = SelectQuery.Clone() + }; + } + } +} diff --git a/QueryBuilder/Exceptions/CreateTableQuery/InvalidQueryMethodException.cs b/QueryBuilder/Exceptions/CreateTableQuery/InvalidQueryMethodException.cs new file mode 100644 index 00000000..8a83ab81 --- /dev/null +++ b/QueryBuilder/Exceptions/CreateTableQuery/InvalidQueryMethodException.cs @@ -0,0 +1,24 @@ +using System; +using System.Runtime.Serialization; + +namespace SqlKata.Exceptions.CreateTableQuery +{ + public class InvalidQueryMethodException : Exception + { + public InvalidQueryMethodException() + { + } + + public InvalidQueryMethodException(string message) : base(message) + { + } + + public InvalidQueryMethodException(string message, Exception innerException) : base(message, innerException) + { + } + + protected InvalidQueryMethodException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index 4bb9a50f..534b2b1e 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using SqlKata.Contract.CreateTable.DbTableSpecific; +using SqlKata.Exceptions.CreateTableQuery; namespace SqlKata { @@ -45,5 +46,26 @@ public Query CreateTable(IEnumerable columns,TableType return this; } + public Query CreateTableAs(Query selectQuery, TableType tableType) + { + if (selectQuery.Method != "select") + { + throw new InvalidQueryMethodException("Inner query of CREATE TABLE AS must be select query"); + } + + ClearComponent("TableType").AddComponent("TableType",new TableCluase() + { + TableType = tableType, + Component = "TableType" + }); + + AddComponent("CreateTableAsQuery", new CreateTableAsClause + { + SelectQuery = selectQuery, + Component = "CreateTableAsQuery" + }); + + return this; + } } } From fe3247d8e320614af3dabf17c155b7dc957b145a Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Tue, 4 Jul 2023 15:47:33 +0330 Subject: [PATCH 29/33] Create table as is now completed and under test --- Program/Program.cs | 40 ++++++++++----- .../Infrastructure/TestCompiler.cs | 5 ++ QueryBuilder/Compilers/Compiler.cs | 6 +++ .../Abstractions/IColumnCompiler.cs | 3 +- .../Abstractions/ICreateTableAsCompiler.cs | 9 ++++ .../ICreateTableAsFormatFactory.cs | 7 +++ .../ICreateTableAsFormatFiller.cs | 9 ++++ .../DDLCompiler/Abstractions/IDDLCompiler.cs | 1 + .../IOracleCreateTableDbExtender.cs | 9 ++++ .../Abstractions/ISqlCreateCommandUtil.cs | 1 + .../ColumnCompilers/ColumnCompiler.cs | 11 ++-- .../CreateTableAsCompiler.cs | 23 +++++++++ .../MySqlCreateCommandUtil.cs | 5 ++ .../OracleCreateCommandUtil.cs | 5 +- .../PostgresqlCreateCommandUtil.cs | 4 ++ .../SqlServerCreateCommandUtil.cs | 4 ++ .../SqliteCreateCommandUtil.cs | 5 ++ .../OracleCreateTableDbExtender.cs | 18 +++++++ .../MySqlCreateTableFormatFactory.cs | 2 +- .../OracleCreateTableFormatFactory.cs | 2 +- .../PostgresqlCreateTableFormatFactory.cs | 2 +- .../SqlServerCreateTableFormatFactory.cs | 2 +- .../CreateTableAsFormatFactory.cs | 13 +++++ .../MySqlCreateQueryFormatFiller.cs | 10 ++-- .../OracleCreateQueryFormatFiller.cs | 25 +++++++--- .../PostgresqlCreateQueryFormatFiller.cs | 13 +++-- .../SqlServerCreateQueryFormatFiller.cs | 7 ++- .../CreateTableAsFormatFiller.cs | 37 ++++++++++++++ .../Compilers/DDLCompiler/DDLCompiler.cs | 14 +++++- QueryBuilder/Compilers/FirebirdCompiler.cs | 5 ++ QueryBuilder/Compilers/MySqlCompiler.cs | 7 +++ QueryBuilder/Compilers/OracleCompiler.cs | 7 +++ QueryBuilder/Compilers/PostgresCompiler.cs | 8 +++ QueryBuilder/Compilers/SqlServerCompiler.cs | 7 +++ QueryBuilder/Compilers/SqliteCompiler.cs | 5 ++ .../CreateTable/TableColumnDefinitionDto.cs | 1 - QueryBuilder/KataDependencyInjection.cs | 13 +++++ QueryBuilder/Query.CreateTable.cs | 50 +++++++++++-------- 38 files changed, 329 insertions(+), 66 deletions(-) create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFiller.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IOracleCreateTableDbExtender.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableAsCompiler.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/DBSpecificQueries/OracleCreateTableDbExtender.cs rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/{ => CreateTable}/MySqlCreateTableFormatFactory.cs (94%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/{ => CreateTable}/OracleCreateTableFormatFactory.cs (94%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/{ => CreateTable}/PostgresqlCreateTableFormatFactory.cs (94%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/{ => CreateTable}/SqlServerCreateTableFormatFactory.cs (94%) create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/{ => CreateTable}/MySqlCreateQueryFormatFiller.cs (81%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/{ => CreateTable}/OracleCreateQueryFormatFiller.cs (60%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/{ => CreateTable}/PostgresqlCreateQueryFormatFiller.cs (73%) rename QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/{ => CreateTable}/SqlServerCreateQueryFormatFiller.cs (92%) create mode 100644 QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTableAs/CreateTableAsFormatFiller.cs diff --git a/Program/Program.cs b/Program/Program.cs index 7d22285a..e9aca0db 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -4,6 +4,7 @@ using SqlKata; using SqlKata.Compilers; using SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.DBSpecificQueries; using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; using SqlKata.Contract.CreateTable.DbTableSpecific; @@ -20,16 +21,34 @@ static void Main(string[] args) serviceCollection.AddKataServices(); var provider = serviceCollection.BuildServiceProvider(); var compilerProvider = provider.GetRequiredService(); - var compiler = compilerProvider.CreateCompiler(DataSource.Oracle); + var compiler = compilerProvider.CreateCompiler(DataSource.SqlServer); + var query = CreateTable(); + //var query = CreateTableAs(); + Console.WriteLine(compiler.Compile(query)); + + + + } + + private static Query CreateTableAs() + { + var selectQuery = new Query("Users").Select("id", "fullname", "age"); + var query = new Query("SampleUsers").CreateTableAs(selectQuery, TableType.Temporary, + new OracleDbTableExtensions() { OnCommitPreserveRows = true }); + return query; + } + + private static Query CreateTable() + { var query = new Query("Users").CreateTable(new List() { new() { ColumnName = "id", - ColumnDbType = new OracleDBColumn() + ColumnDbType = new SqlServerDBColumn() { - OracleDbType = OracleDbType.Int32 + SqlServerDbType = SqlServerDbType.BigInt }, IsAutoIncrement = true, IsNullable = false, @@ -39,22 +58,19 @@ static void Main(string[] args) new() { ColumnName = "FullName", - ColumnDbType = new OracleDBColumn() + ColumnDbType = new SqlServerDBColumn() { - OracleDbType = OracleDbType.Varchar2, - Length = 30 + SqlServerDbType = SqlServerDbType.Varchar, + Length = 30, + Collation = "Arabiv_Ci_100_Ai" }, IsAutoIncrement = false, IsNullable = false, IsPrimaryKey = false, IsUnique = true, } - }, TableType.Temporary,new OracleDbTableExtensions(){OnCommitPreserveRows = true}); - - Console.WriteLine(compiler.Compile(query)); - - - + }, TableType.Temporary); + return query; } } } diff --git a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs index fd4a6e01..5bdc8adf 100644 --- a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs +++ b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs @@ -16,6 +16,11 @@ public virtual MethodInfo Call_FindCompilerMethodInfo(Type clauseType, string me return FindCompilerMethodInfo(clauseType, methodName); } + protected override SqlResult CompileCreateTableAs(Query query) + { + throw new NotImplementedException(); + } + protected override SqlResult CompileCreateTable(Query query) { throw new NotImplementedException(); diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index bd107ae2..25cd5eee 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -128,6 +128,10 @@ protected virtual SqlResult CompileRaw(Query query) { ctx = CompileCreateTable(query); } + else if (query.Method == "CreateTableAs") + { + ctx = CompileCreateTableAs(query); + } else { if (query.Method == "aggregate") @@ -153,6 +157,8 @@ protected virtual SqlResult CompileRaw(Query query) return ctx; } + protected abstract SqlResult CompileCreateTableAs(Query query); + /// /// Add the passed operator(s) to the white list so they can be used with /// the Where/Having methods, this prevent passing arbitrary operators diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs index ea13c314..f7bbe036 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs @@ -1,10 +1,11 @@ using System.Collections.Generic; using System.Text; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers.DDLCompiler.Abstractions { internal interface IColumnCompiler { - string CompileCreateTableColumns(List createTableColumnClauses); + string CompileCreateTableColumns(List createTableColumnClauses,DataSource dataSource); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsCompiler.cs new file mode 100644 index 00000000..14faec7e --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsCompiler.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableAsCompiler + { + string CompileCreateAsQuery(Query query, DataSource dataSource,string compiledSelectQuery); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFactory.cs new file mode 100644 index 00000000..8ecc363e --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFactory.cs @@ -0,0 +1,7 @@ +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableAsFormatFactory + { + string MakeCreateTableAsFormat(); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFiller.cs new file mode 100644 index 00000000..da1155aa --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableAsFormatFiller.cs @@ -0,0 +1,9 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ICreateTableAsFormatFiller + { + string FillCreateTableAsQuery(string queryFormat,string compiledSelectQuery,Query query,DataSource dataSource); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs index 4ea02379..7662f4a3 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -5,5 +5,6 @@ namespace SqlKata.Compilers.DDLCompiler.Abstractions public interface IDDLCompiler { SqlResult CompileCreateTable(Query query,DataSource dataSource); + SqlResult CompileCreateTableAs(Query query, DataSource dataSource,string compiledSelectQuery); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IOracleCreateTableDbExtender.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IOracleCreateTableDbExtender.cs new file mode 100644 index 00000000..ce275e5f --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IOracleCreateTableDbExtender.cs @@ -0,0 +1,9 @@ +using SqlKata.Clauses; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface IOracleCreateTableDbExtender + { + string GetOnCommitBehaviour(CreateTableQueryExtensionClause createTableQueryExtensionClause); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs index 2470cd45..87562a47 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs @@ -7,5 +7,6 @@ internal interface ISqlCreateCommandUtil { DataSource DataSource { get; } string AutoIncrementIdentityCommandGenerator(); + string GetTempTableClause(); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs index 807d648b..15c87d4b 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs @@ -2,19 +2,20 @@ using System.Linq; using System.Text; using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; using SqlKata.Exceptions.CreateTableQuery; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers { internal class ColumnCompiler : IColumnCompiler { - private readonly ISqlCreateCommandUtil _sqlCommandUtil; + private readonly ISqlCreateCommandProvider _sqlCreateCommandProvider; - public ColumnCompiler(ISqlCreateCommandUtil sqlCommandUtil) + public ColumnCompiler(ISqlCreateCommandProvider sqlCreateCommandProvider) { - _sqlCommandUtil = sqlCommandUtil; + this._sqlCreateCommandProvider = sqlCreateCommandProvider; } - public string CompileCreateTableColumns(List createTableColumnClauses) + public string CompileCreateTableColumns(List createTableColumnClauses,DataSource dataSource) { var queryString = new StringBuilder(); var identityAndAutoIncrementColumns = createTableColumnClauses.Where(x => x.IsIdentity || x.IsAutoIncrement); @@ -28,7 +29,7 @@ public string CompileCreateTableColumns(List createTableColum var collate = columnClause.Collate == null ? "" : $"Collate {columnClause.Collate}"; if (columnClause.IsIdentity || columnClause.IsAutoIncrement) { - queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {_sqlCommandUtil.AutoIncrementIdentityCommandGenerator()},\n"); + queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {_sqlCreateCommandProvider.GetSqlCreateCommandUtil(dataSource).AutoIncrementIdentityCommandGenerator()},\n"); continue; } queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {nullOrNot},\n"); diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableAsCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableAsCompiler.cs new file mode 100644 index 00000000..ec585b54 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/CreateTableAsCompiler.cs @@ -0,0 +1,23 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers +{ + internal class CreateTableAsCompiler : ICreateTableAsCompiler + { + private readonly ICreateTableAsFormatFactory _createTableAsFormatFactory; + private readonly ICreateTableAsFormatFiller _createTableAsFormatFiller; + + public CreateTableAsCompiler(ICreateTableAsFormatFiller createTableAsFormatFiller, ICreateTableAsFormatFactory createTableAsFormatFactory) + { + _createTableAsFormatFiller = createTableAsFormatFiller; + _createTableAsFormatFactory = createTableAsFormatFactory; + } + + public string CompileCreateAsQuery(Query query, DataSource dataSource, string compiledSelectQuery) + { + var createTableAsFormat = _createTableAsFormatFactory.MakeCreateTableAsFormat(); + return _createTableAsFormatFiller.FillCreateTableAsQuery(createTableAsFormat,compiledSelectQuery,query,dataSource); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs index 7231cce3..d6b90ab1 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs @@ -12,5 +12,10 @@ public string AutoIncrementIdentityCommandGenerator() { return "AUTO_INCREMENT "; } + + public string GetTempTableClause() + { + return "TEMPORARY"; + } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs index 1bf63862..6720fb38 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs @@ -1,6 +1,5 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -using SqlKata.Contract.CreateTable; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils { @@ -12,5 +11,9 @@ public string AutoIncrementIdentityCommandGenerator() { return "GENERATED ALWAYS AS IDENTITY "; } + public string GetTempTableClause() + { + return "Global TEMPORARY"; + } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs index e53bdc45..cfa93681 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs @@ -12,5 +12,9 @@ public string AutoIncrementIdentityCommandGenerator() { return ""; } + public string GetTempTableClause() + { + return "TEMPORARY"; + } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs index 529b2887..bf3f4805 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs @@ -12,5 +12,9 @@ public string AutoIncrementIdentityCommandGenerator() { return "IDENTITY(1,1) "; } + public string GetTempTableClause() + { + return ""; + } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs index 456470a5..e8bb0fd5 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs @@ -12,5 +12,10 @@ public string AutoIncrementIdentityCommandGenerator() { return "AUTOINCREMENT "; } + + public string GetTempTableClause() + { + return "TEMPORARY"; + } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/DBSpecificQueries/OracleCreateTableDbExtender.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/DBSpecificQueries/OracleCreateTableDbExtender.cs new file mode 100644 index 00000000..4de538cf --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/DBSpecificQueries/OracleCreateTableDbExtender.cs @@ -0,0 +1,18 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Contract.CreateTable.DbTableSpecific; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.DBSpecificQueries +{ + public class OracleCreateTableDbExtender : IOracleCreateTableDbExtender + { + public string GetOnCommitBehaviour(CreateTableQueryExtensionClause createTableQueryExtensionClause) + { + if (createTableQueryExtensionClause == null) + return "on commit delete rows"; + var commitPreserveRows = createTableQueryExtensionClause.CreateDbTableExtension != null && ((OracleDbTableExtensions)createTableQueryExtensionClause.CreateDbTableExtension) + .OnCommitPreserveRows; + return commitPreserveRows ? "on commit preserve rows" : "on commit delete rows"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs similarity index 94% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs index 303d5331..dac1808e 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/MySqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable { internal class MySqlCreateTableFormatFactory : ICreateQueryFormatFactory { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs similarity index 94% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs index 00a5b68c..51830ae5 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/OracleCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable { internal class OracleCreateTableFormatFactory : ICreateQueryFormatFactory { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs similarity index 94% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs index 84f94fd1..b5bfc288 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/PostgresqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable { internal class PostgresqlCreateTableFormatFactory : ICreateQueryFormatFactory { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs similarity index 94% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs index 04d0e35c..c2b64d6e 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/SqlServerCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs @@ -1,7 +1,7 @@ using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable { internal class SqlServerCreateTableFormatFactory : ICreateQueryFormatFactory { diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs new file mode 100644 index 00000000..acce1630 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs @@ -0,0 +1,13 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTableAs +{ + public class CreateTableAsFormatFactory : ICreateTableAsFormatFactory + { + public string MakeCreateTableAsFormat() + { + return @"CREATE {0} TABLE {1} {2} + As ({3}) "; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/MySqlCreateQueryFormatFiller.cs similarity index 81% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/MySqlCreateQueryFormatFiller.cs index 31936fc3..9b37c2d1 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/MySqlCreateQueryFormatFiller.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/MySqlCreateQueryFormatFiller.cs @@ -3,19 +3,21 @@ using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable { internal class MySqlCreateQueryFormatFiller : ICreateQueryFormatFiller { private readonly IColumnCompiler _columnCompiler; private readonly IPrimaryKeyCompiler _primaryKeyCompiler; private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + private readonly ISqlCreateCommandUtil _createCommandUtil; - public MySqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + public MySqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler, ISqlCreateCommandProvider createCommandProvider) { _columnCompiler = columnCompiler; _primaryKeyCompiler = primaryKeyCompiler; _uniqueConstraintCompiler = uniqueConstraintCompiler; + _createCommandUtil = createCommandProvider.GetSqlCreateCommandUtil(DataSource.MySql); } public DataSource DataSource { get; } = DataSource.MySql; @@ -24,11 +26,11 @@ public string FillQueryFormat(string queryFormat,Query query) var createTableColumnClauses = query.GetComponents("CreateTableColumn"); var tableName = query.GetOneComponent("from").Table; var tableType = query.GetOneComponent("TableType").TableType; - var tempString = tableType == TableType.Temporary ? "TEMPORARY" : ""; + var tempString = tableType == TableType.Temporary ? _createCommandUtil.GetTempTableClause() : ""; return string.Format(queryFormat, tempString, tableName, - _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.MySql), _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) ); diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs similarity index 60% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs index 2d4c4a2a..b9b94188 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/OracleCreateQueryFormatFiller.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs @@ -4,42 +4,51 @@ using SqlKata.Contract.CreateTable; using SqlKata.Contract.CreateTable.DbTableSpecific; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable { internal class OracleCreateQueryFormatFiller : ICreateQueryFormatFiller { private readonly IColumnCompiler _columnCompiler; private readonly IPrimaryKeyCompiler _primaryKeyCompiler; private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + private readonly ISqlCreateCommandUtil _sqlCreateCommandUtil; + private readonly IOracleCreateTableDbExtender _oracleCreateTableDbExtender; - public OracleCreateQueryFormatFiller(IUniqueConstraintCompiler uniqueConstraintCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IColumnCompiler columnCompiler) + public OracleCreateQueryFormatFiller(IUniqueConstraintCompiler uniqueConstraintCompiler, + IPrimaryKeyCompiler primaryKeyCompiler, IColumnCompiler columnCompiler, + ISqlCreateCommandProvider sqlCreateCommandProvider, + IOracleCreateTableDbExtender oracleCreateTableDbExtender) { _uniqueConstraintCompiler = uniqueConstraintCompiler; _primaryKeyCompiler = primaryKeyCompiler; _columnCompiler = columnCompiler; + _oracleCreateTableDbExtender = oracleCreateTableDbExtender; + _sqlCreateCommandUtil = sqlCreateCommandProvider.GetSqlCreateCommandUtil(DataSource.Oracle); } public DataSource DataSource { get; } = DataSource.Oracle; - public string FillQueryFormat(string queryFormat,Query query) + + public string FillQueryFormat(string queryFormat, Query query) { var createTableColumnClauses = query.GetComponents("CreateTableColumn"); var tableName = query.GetOneComponent("from").Table; var tableType = query.GetOneComponent("TableType").TableType; - var tempString = tableType == TableType.Temporary ? "GLOBAL TEMPORARY" : ""; + var tempString = tableType == TableType.Temporary ? _sqlCreateCommandUtil.GetTempTableClause() : ""; - var tableExtensions = (OracleDbTableExtensions)query.GetOneComponent("CreateTableExtension")?.CreateDbTableExtension; - var onCommitBehaviour = tableExtensions != null && tableType == TableType.Temporary && tableExtensions.OnCommitPreserveRows ? "on commit preserve rows" : "on commit delete rows" ; + var tableExtensions = query + .GetOneComponent("CreateTableExtension"); + var onCommitBehaviour = tableType == TableType.Temporary ? _oracleCreateTableDbExtender.GetOnCommitBehaviour(tableExtensions) : ""; string hint = ""; return string.Format(queryFormat, tempString, hint, tableName, - _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.Oracle), _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses), onCommitBehaviour - ); + ); } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs similarity index 73% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs index 8b488676..e9b31e25 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/PostgresqlCreateQueryFormatFiller.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs @@ -3,33 +3,36 @@ using SqlKata.Compilers.Enums; using SqlKata.Contract.CreateTable; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable { internal class PostgresqlCreateQueryFormatFiller : ICreateQueryFormatFiller { private readonly IColumnCompiler _columnCompiler; private readonly IPrimaryKeyCompiler _primaryKeyCompiler; private readonly IUniqueConstraintCompiler _uniqueConstraintCompiler; + private readonly ISqlCreateCommandUtil _sqlCreateCommandUtil; - public PostgresqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, IUniqueConstraintCompiler uniqueConstraintCompiler) + public PostgresqlCreateQueryFormatFiller(IColumnCompiler columnCompiler, IPrimaryKeyCompiler primaryKeyCompiler, + IUniqueConstraintCompiler uniqueConstraintCompiler, ISqlCreateCommandProvider sqlCreateCommandProvider) { _columnCompiler = columnCompiler; _primaryKeyCompiler = primaryKeyCompiler; _uniqueConstraintCompiler = uniqueConstraintCompiler; + _sqlCreateCommandUtil = sqlCreateCommandProvider.GetSqlCreateCommandUtil(DataSource.Postgresql); } public DataSource DataSource { get; } = DataSource.Postgresql; - public string FillQueryFormat(string queryFormat,Query query) + public string FillQueryFormat(string queryFormat, Query query) { var createTableColumnClauses = query.GetComponents("CreateTableColumn"); var tableName = query.GetOneComponent("from").Table; var tableType = query.GetOneComponent("TableType").TableType; - var tempString = tableType == TableType.Temporary ? "TEMPORARY" : ""; + var tempString = tableType == TableType.Temporary ? _sqlCreateCommandUtil.GetTempTableClause() : ""; return string.Format(queryFormat, tempString, tableName, - _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.Postgresql), _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) ); diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs similarity index 92% rename from QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs rename to QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs index 717639a8..d8735a34 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/SqlServerCreateQueryFormatFiller.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs @@ -1,8 +1,7 @@ -using SqlKata.Clauses; -using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; -namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable { internal class SqlServerCreateQueryFormatFiller : ICreateQueryFormatFiller { @@ -24,7 +23,7 @@ public string FillQueryFormat(string queryFormat,Query query) var tableName = query.GetOneComponent("from").Table; return string.Format(queryFormat, tableName, - _columnCompiler.CompileCreateTableColumns(createTableColumnClauses), + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.SqlServer), _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) ); diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTableAs/CreateTableAsFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTableAs/CreateTableAsFormatFiller.cs new file mode 100644 index 00000000..14faff9c --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTableAs/CreateTableAsFormatFiller.cs @@ -0,0 +1,37 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTableAs +{ + internal class CreateTableAsFormatFiller : ICreateTableAsFormatFiller + { + private readonly ISqlCreateCommandProvider _sqlCreateCommandProvider; + private readonly IOracleCreateTableDbExtender _oracleCreateTableDbExtender; + + + public CreateTableAsFormatFiller(ISqlCreateCommandProvider sqlCreateCommandProvider, IOracleCreateTableDbExtender oracleCreateTableDbExtender) + { + _sqlCreateCommandProvider = sqlCreateCommandProvider; + _oracleCreateTableDbExtender = oracleCreateTableDbExtender; + } + + + public string FillCreateTableAsQuery(string queryFormat,string compiledSelectQuery, Query query,DataSource dataSource) + { + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempTableClause = tableType == TableType.Temporary ? _sqlCreateCommandProvider.GetSqlCreateCommandUtil(dataSource).GetTempTableClause() : ""; + var isOracleTempTable = dataSource == DataSource.Oracle && tableType == TableType.Temporary; + var tableExtensions = query + .GetOneComponent("CreateTableExtension"); + var onCommitBehaviour = isOracleTempTable ? _oracleCreateTableDbExtender.GetOnCommitBehaviour(tableExtensions) : ""; + return string.Format(queryFormat, + tempTableClause, + tableName, + onCommitBehaviour, + compiledSelectQuery); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs index a5ce4b8b..e0edaa82 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -6,10 +6,12 @@ namespace SqlKata.Compilers.DDLCompiler internal class DDLCompiler : IDDLCompiler { private readonly ICreateTableQueryCompiler _createTableQueryCompiler; + private readonly ICreateTableAsCompiler _createTableAsCompiler; - public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler) + public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler, ICreateTableAsCompiler createTableAsCompiler) { _createTableQueryCompiler = createTableQueryCompiler; + _createTableAsCompiler = createTableAsCompiler; } @@ -24,5 +26,15 @@ public SqlResult CompileCreateTable(Query query,DataSource dataSource) return result; } + public SqlResult CompileCreateTableAs(Query query, DataSource dataSource,string compiledSelectQuery) + { + var result = new SqlResult() + { + Query = query.Clone() + }; + var queryString = _createTableAsCompiler.CompileCreateAsQuery(query,dataSource,compiledSelectQuery); + result.RawSql = queryString; + return result; + } } } diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs index c29449dc..bbf0cbbb 100644 --- a/QueryBuilder/Compilers/FirebirdCompiler.cs +++ b/QueryBuilder/Compilers/FirebirdCompiler.cs @@ -125,6 +125,11 @@ public override string CompileFalse() return "0"; } + protected override SqlResult CompileCreateTableAs(Query query) + { + throw new System.NotImplementedException(); + } + protected override SqlResult CompileCreateTable(Query query) { throw new System.NotImplementedException(); diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs index 59f2f6b2..3c655b47 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -1,3 +1,4 @@ +using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; @@ -56,6 +57,12 @@ public override string CompileLimit(SqlResult ctx) } + protected override SqlResult CompileCreateTableAs(Query query) + { + var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; + return _ddlCompiler.CompileCreateTableAs(query,DataSource.MySql,compiledSelectQuery); + } + protected override SqlResult CompileCreateTable(Query query) { return _ddlCompiler.CompileCreateTable(query,DataSource.MySql); diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 5477976a..3270ac85 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; @@ -27,6 +28,12 @@ public OracleCompiler() public bool UseLegacyPagination { get; set; } = false; protected override string SingleRowDummyTableName => "DUAL"; + protected override SqlResult CompileCreateTableAs(Query query) + { + var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; + return _ddlCompiler.CompileCreateTableAs(query,DataSource.Oracle,compiledSelectQuery); + } + protected override SqlResult CompileSelectQuery(Query query) { if (!UseLegacyPagination) diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs index c1b73bf9..11379553 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -1,5 +1,6 @@ using System; using System.Linq; +using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; @@ -104,6 +105,13 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond return sql; } + + protected override SqlResult CompileCreateTableAs(Query query) + { + var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; + return _ddlCompiler.CompileCreateTableAs(query,DataSource.Postgresql,compiledSelectQuery); + } + protected override SqlResult CompileCreateTable(Query query) { return _ddlCompiler.CompileCreateTable(query,DataSource.Postgresql); diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 6674b27c..125465e6 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,4 +1,5 @@ using System.Linq; +using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; @@ -22,6 +23,12 @@ public SqlServerCompiler() public override string EngineCode { get; } = EngineCodes.SqlServer; public bool UseLegacyPagination { get; set; } = false; + protected override SqlResult CompileCreateTableAs(Query query) + { + var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; + return _ddlCompiler.CompileCreateTableAs(query,DataSource.SqlServer,compiledSelectQuery); + } + protected override SqlResult CompileSelectQuery(Query query) { if (!UseLegacyPagination || !query.HasOffset(EngineCode)) diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs index 0f53d1cd..551aa674 100644 --- a/QueryBuilder/Compilers/SqliteCompiler.cs +++ b/QueryBuilder/Compilers/SqliteCompiler.cs @@ -77,6 +77,11 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond return sql; } + protected override SqlResult CompileCreateTableAs(Query query) + { + throw new System.NotImplementedException(); + } + protected override SqlResult CompileCreateTable(Query query) { throw new System.NotImplementedException(); diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs index 192ef226..da22887d 100644 --- a/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs @@ -11,6 +11,5 @@ public class TableColumnDefinitionDto public bool IsUnique { get; set; } public bool IsIdentity { get; set; } public bool IsAutoIncrement { get; set; } - public string Collate { get; set; } } } diff --git a/QueryBuilder/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs index 7ceb588b..cde35c90 100644 --- a/QueryBuilder/KataDependencyInjection.cs +++ b/QueryBuilder/KataDependencyInjection.cs @@ -5,9 +5,14 @@ using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.ColumnCompilers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableCompilers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.DBSpecificQueries; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.PrimaryKeyCompilers; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTableAs; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTableAs; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers; using SqlKata.Compilers.DDLCompiler.Providers; using SqlKata.Compilers.Providers; @@ -23,6 +28,7 @@ public static IServiceCollection AddKataServices(this IServiceCollection service services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); + services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); @@ -50,8 +56,15 @@ public static IServiceCollection AddKataServices(this IServiceCollection service services.AddSingleton(); services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + services.AddSingleton(); + services.AddSingleton(); + + return services; } } diff --git a/QueryBuilder/Query.CreateTable.cs b/QueryBuilder/Query.CreateTable.cs index 534b2b1e..462da2a4 100644 --- a/QueryBuilder/Query.CreateTable.cs +++ b/QueryBuilder/Query.CreateTable.cs @@ -13,11 +13,9 @@ public Query CreateTable(IEnumerable columns,TableType { Method = "CreateTable"; - ClearComponent("TableType").AddComponent("TableType",new TableCluase() - { - TableType = tableType, - Component = "TableType" - }); + AddTableTypeComponent(tableType); + + AddDbSpecificCreateTableComponent(createDbTableExtension); columns.ToList().ForEach(column => { @@ -31,33 +29,23 @@ public Query CreateTable(IEnumerable columns,TableType IsPrimaryKey = column.IsPrimaryKey, IsAutoIncrement = column.IsAutoIncrement, IsIdentity = column.IsIdentity, - Collate = column.Collate + Collate = column.ColumnDbType.Collation }); }); - if (createDbTableExtension != null) - { - AddComponent("CreateTableExtension", new CreateTableQueryExtensionClause() - { - CreateDbTableExtension = createDbTableExtension, - Component = "CreateTableExtension" - }); - } return this; } - public Query CreateTableAs(Query selectQuery, TableType tableType) + public Query CreateTableAs(Query selectQuery, TableType tableType = TableType.Permanent,CreateDbTableExtension createDbTableExtension = null) { + Method = "CreateTableAs"; if (selectQuery.Method != "select") { throw new InvalidQueryMethodException("Inner query of CREATE TABLE AS must be select query"); } - ClearComponent("TableType").AddComponent("TableType",new TableCluase() - { - TableType = tableType, - Component = "TableType" - }); + AddDbSpecificCreateTableComponent(createDbTableExtension); + AddTableTypeComponent(tableType); AddComponent("CreateTableAsQuery", new CreateTableAsClause { @@ -67,5 +55,27 @@ public Query CreateTableAs(Query selectQuery, TableType tableType) return this; } + + private void AddDbSpecificCreateTableComponent(CreateDbTableExtension createDbTableExtension) + { + if (createDbTableExtension != null) + { + AddComponent("CreateTableExtension", new CreateTableQueryExtensionClause() + { + CreateDbTableExtension = createDbTableExtension, + Component = "CreateTableExtension" + }); + } + } + private void AddTableTypeComponent(TableType tableType) + { + ClearComponent("TableType").AddComponent("TableType", new TableCluase() + { + TableType = tableType, + Component = "TableType" + }); + } + + } } From 298428e86b8b40f9f1f82a10689d7ce2c94691de Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Tue, 4 Jul 2023 18:35:59 +0330 Subject: [PATCH 30/33] Add DropTable Add Truncate the system is under test --- Program/Program.cs | 14 +++--- QueryBuilder/Compilers/Compiler.cs | 24 +++++++++++ .../DDLCompiler/Abstractions/IDDLCompiler.cs | 2 + .../Abstractions/IDropTableQueryFactory.cs | 7 +++ .../ITruncateTableQueryFactory.cs | 7 +++ .../Compilers/DDLCompiler/DDLCompiler.cs | 43 +++++++++++++++---- .../DeleteDdl/DropTableQueryFactory.cs | 13 ++++++ .../DeleteDdl/TruncateTableQueryFactory.cs | 13 ++++++ QueryBuilder/Compilers/MySqlCompiler.cs | 7 ++- QueryBuilder/Compilers/OracleCompiler.cs | 16 ++++--- QueryBuilder/Compilers/PostgresCompiler.cs | 7 ++- QueryBuilder/Compilers/SqlServerCompiler.cs | 7 ++- QueryBuilder/Compilers/SqliteCompiler.cs | 3 +- QueryBuilder/KataDependencyInjection.cs | 6 ++- QueryBuilder/Query.Drop.cs | 17 ++++++++ 15 files changed, 149 insertions(+), 37 deletions(-) create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/IDropTableQueryFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/Abstractions/ITruncateTableQueryFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/DeleteDdl/DropTableQueryFactory.cs create mode 100644 QueryBuilder/Compilers/DDLCompiler/DeleteDdl/TruncateTableQueryFactory.cs create mode 100644 QueryBuilder/Query.Drop.cs diff --git a/Program/Program.cs b/Program/Program.cs index e9aca0db..ffe19462 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -23,7 +23,9 @@ static void Main(string[] args) var compilerProvider = provider.GetRequiredService(); var compiler = compilerProvider.CreateCompiler(DataSource.SqlServer); - var query = CreateTable(); + //var query = new Query("Users").DropTable(); + var query = new Query("Users").Truncate(); + //var query = CreateTable(); //var query = CreateTableAs(); Console.WriteLine(compiler.Compile(query)); @@ -46,9 +48,9 @@ private static Query CreateTable() new() { ColumnName = "id", - ColumnDbType = new SqlServerDBColumn() + ColumnDbType = new OracleDBColumn() { - SqlServerDbType = SqlServerDbType.BigInt + OracleDbType = OracleDbType.Int32 }, IsAutoIncrement = true, IsNullable = false, @@ -58,11 +60,11 @@ private static Query CreateTable() new() { ColumnName = "FullName", - ColumnDbType = new SqlServerDBColumn() + ColumnDbType = new OracleDBColumn() { - SqlServerDbType = SqlServerDbType.Varchar, + OracleDbType = OracleDbType.Varchar2, Length = 30, - Collation = "Arabiv_Ci_100_Ai" + //Collation = "Arabiv_Ci_100_Ai" }, IsAutoIncrement = false, IsNullable = false, diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index 25cd5eee..37b4e976 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -9,6 +9,7 @@ namespace SqlKata.Compilers public abstract partial class Compiler { private readonly ConditionsCompilerProvider _compileConditionMethodsProvider; + protected IDDLCompiler DdlCompiler; protected virtual string parameterPlaceholder { get; set; } = "?"; protected virtual string parameterPrefix { get; set; } = "@p"; protected virtual string OpeningIdentifier { get; set; } = "\""; @@ -27,6 +28,11 @@ protected Compiler() _compileConditionMethodsProvider = new ConditionsCompilerProvider(this); } + protected Compiler(IDDLCompiler ddlCompiler) : this() + { + DdlCompiler = ddlCompiler; + } + public virtual string EngineCode { get; } /// @@ -132,6 +138,14 @@ protected virtual SqlResult CompileRaw(Query query) { ctx = CompileCreateTableAs(query); } + else if (query.Method == "Drop") + { + ctx = CompileDropTable(query); + } + else if (query.Method == "Truncate") + { + ctx = CompileTruncateTable(query); + } else { if (query.Method == "aggregate") @@ -157,6 +171,16 @@ protected virtual SqlResult CompileRaw(Query query) return ctx; } + protected virtual SqlResult CompileTruncateTable(Query query) + { + return DdlCompiler.CompileTruncateTable(query); + } + + protected virtual SqlResult CompileDropTable(Query query) + { + return DdlCompiler.CompileDropTable(query); + } + protected abstract SqlResult CompileCreateTableAs(Query query); /// diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs index 7662f4a3..352681eb 100644 --- a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -6,5 +6,7 @@ public interface IDDLCompiler { SqlResult CompileCreateTable(Query query,DataSource dataSource); SqlResult CompileCreateTableAs(Query query, DataSource dataSource,string compiledSelectQuery); + SqlResult CompileDropTable(Query query); + SqlResult CompileTruncateTable(Query query); } } diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDropTableQueryFactory.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDropTableQueryFactory.cs new file mode 100644 index 00000000..9e8d8c3f --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDropTableQueryFactory.cs @@ -0,0 +1,7 @@ +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + public interface IDropTableQueryFactory + { + string CompileQuery(Query query); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ITruncateTableQueryFactory.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ITruncateTableQueryFactory.cs new file mode 100644 index 00000000..676a99d9 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ITruncateTableQueryFactory.cs @@ -0,0 +1,7 @@ +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + public interface ITruncateTableQueryFactory + { + string CompileQuery(Query query); + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs index e0edaa82..21a5bbdf 100644 --- a/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -7,33 +7,58 @@ internal class DDLCompiler : IDDLCompiler { private readonly ICreateTableQueryCompiler _createTableQueryCompiler; private readonly ICreateTableAsCompiler _createTableAsCompiler; + private readonly IDropTableQueryFactory _dropTableQueryFactory; + private readonly ITruncateTableQueryFactory _truncateTableQueryFactory; - public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler, ICreateTableAsCompiler createTableAsCompiler) + public DDLCompiler(ICreateTableQueryCompiler createTableQueryCompiler, + ICreateTableAsCompiler createTableAsCompiler, ITruncateTableQueryFactory truncateTableQueryFactory, + IDropTableQueryFactory dropTableQueryFactory) { _createTableQueryCompiler = createTableQueryCompiler; _createTableAsCompiler = createTableAsCompiler; + _truncateTableQueryFactory = truncateTableQueryFactory; + _dropTableQueryFactory = dropTableQueryFactory; } - public SqlResult CompileCreateTable(Query query,DataSource dataSource) + public SqlResult CompileCreateTable(Query query, DataSource dataSource) { var result = new SqlResult() { Query = query.Clone(), + RawSql = _createTableQueryCompiler.CompileCreateTable(query, dataSource) }; - var queryString = _createTableQueryCompiler.CompileCreateTable(result.Query,dataSource); - result.RawSql = queryString; return result; } - public SqlResult CompileCreateTableAs(Query query, DataSource dataSource,string compiledSelectQuery) + public SqlResult CompileCreateTableAs(Query query, DataSource dataSource, string compiledSelectQuery) { - var result = new SqlResult() + var result = new SqlResult { - Query = query.Clone() + Query = query.Clone(), + RawSql = _createTableAsCompiler.CompileCreateAsQuery(query, dataSource, compiledSelectQuery) + }; + return result; + } + + public SqlResult CompileDropTable(Query query) + { + var result = new SqlResult + { + Query = query.Clone(), + RawSql = _dropTableQueryFactory.CompileQuery(query) + }; + + return result; + } + + public SqlResult CompileTruncateTable(Query query) + { + var result = new SqlResult + { + Query = query.Clone(), + RawSql = _truncateTableQueryFactory.CompileQuery(query) }; - var queryString = _createTableAsCompiler.CompileCreateAsQuery(query,dataSource,compiledSelectQuery); - result.RawSql = queryString; return result; } } diff --git a/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/DropTableQueryFactory.cs b/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/DropTableQueryFactory.cs new file mode 100644 index 00000000..5f1b011f --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/DropTableQueryFactory.cs @@ -0,0 +1,13 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler.DeleteDdl +{ + public class DropTableQueryFactory : IDropTableQueryFactory + { + public string CompileQuery(Query query) + { + var tableName = query.GetOneComponent("from").Table; + return $"Drop Table {tableName}"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/TruncateTableQueryFactory.cs b/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/TruncateTableQueryFactory.cs new file mode 100644 index 00000000..c0cfc4da --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/DeleteDdl/TruncateTableQueryFactory.cs @@ -0,0 +1,13 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; + +namespace SqlKata.Compilers.DDLCompiler.DeleteDdl +{ + public class TruncateTableQueryFactory : ITruncateTableQueryFactory + { + public string CompileQuery(Query query) + { + var tableName = query.GetOneComponent("from").Table; + return $"Truncate Table {tableName}"; + } + } +} diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs index 3c655b47..f4e117ab 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -6,10 +6,9 @@ namespace SqlKata.Compilers { public class MySqlCompiler : Compiler { - private readonly IDDLCompiler _ddlCompiler; public MySqlCompiler(IDDLCompiler ddlCompiler) : this() { - _ddlCompiler = ddlCompiler; + DdlCompiler = ddlCompiler; } public MySqlCompiler() @@ -60,12 +59,12 @@ public override string CompileLimit(SqlResult ctx) protected override SqlResult CompileCreateTableAs(Query query) { var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; - return _ddlCompiler.CompileCreateTableAs(query,DataSource.MySql,compiledSelectQuery); + return DdlCompiler.CompileCreateTableAs(query,DataSource.MySql,compiledSelectQuery); } protected override SqlResult CompileCreateTable(Query query) { - return _ddlCompiler.CompileCreateTable(query,DataSource.MySql); + return DdlCompiler.CompileCreateTable(query,DataSource.MySql); } } } diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs index 3270ac85..d1033276 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Text; using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; using SqlKata.Compilers.Enums; @@ -9,11 +10,9 @@ namespace SqlKata.Compilers { public class OracleCompiler : Compiler { - private readonly IDDLCompiler _ddlCompiler; public OracleCompiler(IDDLCompiler ddlCompiler) : this() { - _ddlCompiler = ddlCompiler; - + DdlCompiler = ddlCompiler; } public OracleCompiler() @@ -31,7 +30,7 @@ public OracleCompiler() protected override SqlResult CompileCreateTableAs(Query query) { var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; - return _ddlCompiler.CompileCreateTableAs(query,DataSource.Oracle,compiledSelectQuery); + return DdlCompiler.CompileCreateTableAs(query,DataSource.Oracle,compiledSelectQuery); } protected override SqlResult CompileSelectQuery(Query query) @@ -189,10 +188,15 @@ protected override SqlResult CompileRemainingInsertClauses( protected override SqlResult CompileCreateTable(Query query) { - return _ddlCompiler.CompileCreateTable(query,DataSource.Oracle); + return DdlCompiler.CompileCreateTable(query,DataSource.Oracle); } - + protected override SqlResult CompileDropTable(Query query) + { + var result = base.CompileDropTable(query); + result.RawSql = new StringBuilder(result.RawSql).Append(" PURGE").ToString(); + return result; + } } diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs index 11379553..b58be879 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -8,10 +8,9 @@ namespace SqlKata.Compilers { public class PostgresCompiler : Compiler { - private readonly IDDLCompiler _ddlCompiler; public PostgresCompiler(IDDLCompiler ddlCompiler) : this() { - _ddlCompiler = ddlCompiler; + DdlCompiler = ddlCompiler; } public PostgresCompiler() @@ -109,12 +108,12 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond protected override SqlResult CompileCreateTableAs(Query query) { var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; - return _ddlCompiler.CompileCreateTableAs(query,DataSource.Postgresql,compiledSelectQuery); + return DdlCompiler.CompileCreateTableAs(query,DataSource.Postgresql,compiledSelectQuery); } protected override SqlResult CompileCreateTable(Query query) { - return _ddlCompiler.CompileCreateTable(query,DataSource.Postgresql); + return DdlCompiler.CompileCreateTable(query,DataSource.Postgresql); } } } diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs index 125465e6..c3278d6d 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -7,10 +7,9 @@ namespace SqlKata.Compilers { public class SqlServerCompiler : Compiler { - private readonly IDDLCompiler _ddlCompiler; public SqlServerCompiler(IDDLCompiler ddlCompiler) : this() { - _ddlCompiler = ddlCompiler; + DdlCompiler = ddlCompiler; } public SqlServerCompiler() @@ -26,7 +25,7 @@ public SqlServerCompiler() protected override SqlResult CompileCreateTableAs(Query query) { var compiledSelectQuery = CompileSelectQuery(query.GetOneComponent("CreateTableAsQuery").SelectQuery).RawSql; - return _ddlCompiler.CompileCreateTableAs(query,DataSource.SqlServer,compiledSelectQuery); + return DdlCompiler.CompileCreateTableAs(query,DataSource.SqlServer,compiledSelectQuery); } protected override SqlResult CompileSelectQuery(Query query) @@ -204,7 +203,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) protected override SqlResult CompileCreateTable(Query query) { - return _ddlCompiler.CompileCreateTable(query,DataSource.SqlServer); + return DdlCompiler.CompileCreateTable(query,DataSource.SqlServer); } } } diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs index 551aa674..ed3d36c5 100644 --- a/QueryBuilder/Compilers/SqliteCompiler.cs +++ b/QueryBuilder/Compilers/SqliteCompiler.cs @@ -5,11 +5,10 @@ namespace SqlKata.Compilers { public class SqliteCompiler : Compiler { - private readonly IDDLCompiler _ddlCompiler; public SqliteCompiler(IDDLCompiler ddlCompiler) { - _ddlCompiler = ddlCompiler; + DdlCompiler = ddlCompiler; } public SqliteCompiler() diff --git a/QueryBuilder/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs index cde35c90..2ba31eec 100644 --- a/QueryBuilder/KataDependencyInjection.cs +++ b/QueryBuilder/KataDependencyInjection.cs @@ -14,6 +14,7 @@ using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTableAs; using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.UniqueConstraintCompilers; +using SqlKata.Compilers.DDLCompiler.DeleteDdl; using SqlKata.Compilers.DDLCompiler.Providers; using SqlKata.Compilers.Providers; using SqlKata.Compilers.Providers.Factories; @@ -63,8 +64,9 @@ public static IServiceCollection AddKataServices(this IServiceCollection service services.AddSingleton(); - - + services.AddSingleton(); + services.AddSingleton(); + return services; } } diff --git a/QueryBuilder/Query.Drop.cs b/QueryBuilder/Query.Drop.cs new file mode 100644 index 00000000..e43a0cdc --- /dev/null +++ b/QueryBuilder/Query.Drop.cs @@ -0,0 +1,17 @@ +namespace SqlKata +{ + public partial class Query + { + public Query DropTable() + { + Method = "Drop"; + return this; + } + public Query Truncate() + { + Method = "Truncate"; + return this; + } + + } +} From aaa858368d34755bda2621ec09c0bf7282715cd5 Mon Sep 17 00:00:00 2001 From: Alireza Eiji Date: Wed, 5 Jul 2023 09:34:09 +0330 Subject: [PATCH 31/33] db column and format was changed --- Program/Program.cs | 6 +++--- .../Factories/CreateTable/MySqlCreateTableFormatFactory.cs | 5 +---- .../CreateTable/OracleCreateTableFormatFactory.cs | 7 ++----- .../CreateTable/PostgresqlCreateTableFormatFactory.cs | 5 +---- .../CreateTable/SqlServerCreateTableFormatFactory.cs | 6 +----- 5 files changed, 8 insertions(+), 21 deletions(-) diff --git a/Program/Program.cs b/Program/Program.cs index ffe19462..c24f15df 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -21,11 +21,11 @@ static void Main(string[] args) serviceCollection.AddKataServices(); var provider = serviceCollection.BuildServiceProvider(); var compilerProvider = provider.GetRequiredService(); - var compiler = compilerProvider.CreateCompiler(DataSource.SqlServer); + var compiler = compilerProvider.CreateCompiler(DataSource.Postgresql); //var query = new Query("Users").DropTable(); - var query = new Query("Users").Truncate(); - //var query = CreateTable(); + //var query = new Query("Users").Truncate(); + var query = CreateTable(); //var query = CreateTableAs(); Console.WriteLine(compiler.Compile(query)); diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs index dac1808e..d60a51ee 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs @@ -9,10 +9,7 @@ internal class MySqlCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE {0} TABLE {1} ( - {2} - {3} - {4} - )"; +{2}{3}{4})"; } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs index 51830ae5..b6b6c17a 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs @@ -9,11 +9,8 @@ internal class OracleCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE {0} {1} TABLE {2} ( - {3} - {4} - {5} - ) - {6}"; +{3}{4}{5}) +{6}"; } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs index b5bfc288..f8f32e87 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs @@ -9,10 +9,7 @@ internal class PostgresqlCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE {0} TABLE {1} ( - {2} - {3} - {4} - )"; +{2}{3}{4})"; } } } diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs index c2b64d6e..ee249b48 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs @@ -9,11 +9,7 @@ internal class SqlServerCreateTableFormatFactory : ICreateQueryFormatFactory public string CreateTableFormat() { return @"CREATE TABLE {0}( - {1} - {2} - {3} - ) - "; +{1}{2}{3})"; } } } From 20275f0e6652493902f9886680e0bb5c35224ff7 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 5 Jul 2023 19:53:24 +0330 Subject: [PATCH 32/33] correct create table as format --- .../Factories/CreateTableAs/CreateTableAsFormatFactory.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs index acce1630..cb98e67f 100644 --- a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs @@ -1,4 +1,4 @@ -using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTableAs { @@ -7,7 +7,7 @@ public class CreateTableAsFormatFactory : ICreateTableAsFormatFactory public string MakeCreateTableAsFormat() { return @"CREATE {0} TABLE {1} {2} - As ({3}) "; +As ({3}) "; } } } From 0fe20e36b1d3851853537a6cc648c0b46465a1d4 Mon Sep 17 00:00:00 2001 From: alirezaeiji Date: Wed, 5 Jul 2023 23:06:47 +0330 Subject: [PATCH 33/33] Add Select Into Query --- Program/Program.cs | 11 ++++++++--- QueryBuilder/Clauses/IntoClause.cs | 16 ++++++++++++++++ QueryBuilder/Compilers/Compiler.cs | 27 +++++++++++++++++++++++++-- QueryBuilder/Query.Select.cs | 25 +++++++++++++++++++++++++ 4 files changed, 74 insertions(+), 5 deletions(-) create mode 100644 QueryBuilder/Clauses/IntoClause.cs diff --git a/Program/Program.cs b/Program/Program.cs index c24f15df..bdc7940d 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -25,12 +25,17 @@ static void Main(string[] args) //var query = new Query("Users").DropTable(); //var query = new Query("Users").Truncate(); - var query = CreateTable(); + //var query = CreateTable(); //var query = CreateTableAs(); - Console.WriteLine(compiler.Compile(query)); - + /* var fromClause = new FromClause() + { + Table = "dbo.user" + }; + Console.WriteLine(compiler.Wrap(fromClause.Table));*/ + var query = new Query("users").Select("Id", "FullName").Into("public.Sample"); + Console.WriteLine(compiler.Compile(query)); } private static Query CreateTableAs() diff --git a/QueryBuilder/Clauses/IntoClause.cs b/QueryBuilder/Clauses/IntoClause.cs new file mode 100644 index 00000000..1eca949e --- /dev/null +++ b/QueryBuilder/Clauses/IntoClause.cs @@ -0,0 +1,16 @@ +namespace SqlKata.Clauses +{ + public class IntoClause : AbstractClause + { + public string TableName { get; set; } + + public override AbstractClause Clone() + { + return new IntoClause() + { + TableName = TableName, + Component = Component + }; + } + } +} diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs index 37b4e976..38c59652 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using System.Text; +using SqlKata.Clauses; using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers @@ -146,6 +147,10 @@ protected virtual SqlResult CompileRaw(Query query) { ctx = CompileTruncateTable(query); } + else if (query.Method == "selectInto") + { + ctx = CompileSelectIntoQuery(query); + } else { if (query.Method == "aggregate") @@ -156,7 +161,6 @@ protected virtual SqlResult CompileRaw(Query query) query = TransformAggregateQuery(query); } - ctx = CompileSelectQuery(query); } @@ -171,6 +175,25 @@ protected virtual SqlResult CompileRaw(Query query) return ctx; } + private SqlResult CompileSelectIntoQuery(Query query) + { + var ctx = new SqlResult + { + Query = query.Clone(), + }; + + var columns = ctx.Query + .GetComponents("select", EngineCode) + .Select(x => CompileColumn(ctx, x)) + .ToList(); + var from = CompileFrom(ctx); + + var intoClause = ctx.Query.GetOneComponent("IntoCluase"); + var newTable = Wrap(intoClause.TableName); + ctx.RawSql = string.Format("SELECT {0} INTO {1} {2}",string.Join(",",columns),newTable,from); + return ctx; + } + protected virtual SqlResult CompileTruncateTable(Query query) { return DdlCompiler.CompileTruncateTable(query); @@ -908,7 +931,7 @@ public virtual string CompileLimit(SqlResult ctx) } /// - /// Compile the random statement into SQL. + /// Compile the random statement newTable SQL. /// /// /// diff --git a/QueryBuilder/Query.Select.cs b/QueryBuilder/Query.Select.cs index 9502c024..00dda236 100644 --- a/QueryBuilder/Query.Select.cs +++ b/QueryBuilder/Query.Select.cs @@ -1,3 +1,4 @@ +using SqlKata.Clauses; using System; using System.Collections.Generic; using System.Linq; @@ -12,6 +13,30 @@ public Query Select(params string[] columns) return Select(columns.AsEnumerable()); } + public Query Into(string newTableName,params string[] newColumnList) + { + Method = "selectInto"; + + newColumnList = newColumnList + .Select(x => Helper.ExpandExpression(x)) + .SelectMany(x => x) + .ToArray(); + + AddComponent("IntoCluase", new IntoClause() + { + TableName = newTableName + }); + + newColumnList.ToList().ForEach(newColumn => { + AddComponent("select",new Column + { + Name = newColumn + }); + }); + + return this; + } + public Query Select(IEnumerable columns) { Method = "select";