change the structure of creating table query

sqlkata · AlirezaEiji191379 · Jun 27, 2023 · Jun 27, 2023 · Jun 27, 2023 · Jun 27, 2023
commit 97d87a4316d6b1a304c3eaf078b67af937001c29
diff --git a/QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs b/QueryBuilder/Clauses/CreateTableQueryExtensionClause.cs
@@ -0,0 +1,24 @@
+using SqlKata.Contract.CreateTable.DbTableSpecific;
+
+namespace SqlKata.Clauses
+{
+    /// <summary>
+    /// 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.
+    /// </summary>
+    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
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace SqlKata.Compilers.DDLCompiler.Abstractions
+{
+    internal interface IColumnCompiler
+    {
+        void CompileCreateTableColumns(StringBuilder queryString, List<CreateTableColumn> createTableColumnClauses);
+    }
+}
diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs 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<CreateTableColumn> createTableColumnClauses);
+    }
+}
diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs 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
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace SqlKata.Compilers.DDLCompiler.Abstractions
+{
+    internal interface IPrimaryKeyCompiler
+    {
+        void CompilePrimaryKey(StringBuilder queryString, List<CreateTableColumn> createTableColumnClauses);
+    }
+}
diff --git a/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs 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<CreateTableColumn> createTableColumnClauses);
+    }
+}
diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs 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<CreateTableColumn> 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/...pilers/DDLCompiler/CreateTableBuilders/CreateTableCompilers/GeneralCreateTableCompiler.cs b/...pilers/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<CreateTableColumn> 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/...CreateCompilers/MySqlCreateCommandUtil.cs → ...TableQueryUtils/MySqlCreateCommandUtil.cs b/...CreateCompilers/MySqlCreateCommandUtil.cs → ...TableQueryUtils/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/...reateCompilers/OracleCreateCommandUtil.cs → ...ableQueryUtils/OracleCreateCommandUtil.cs b/...reateCompilers/OracleCreateCommandUtil.cs → ...ableQueryUtils/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/...eCompilers/PostgresqlCreateCommandUtil.cs → ...QueryUtils/PostgresqlCreateCommandUtil.cs b/...eCompilers/PostgresqlCreateCommandUtil.cs → ...QueryUtils/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/...teCompilers/SqlServerCreateCommandUtil.cs → ...eQueryUtils/SqlServerCreateCommandUtil.cs b/...teCompilers/SqlServerCreateCommandUtil.cs → ...eQueryUtils/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/...eateCompilers/SqliteCreateColmmandUtil.cs → ...ableQueryUtils/SqliteCreateCommandUtil.cs b/...eateCompilers/SqliteCreateColmmandUtil.cs → ...ableQueryUtils/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/...ilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs b/...ilder/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<CreateTableColumn> 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/...ers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs b/...ers/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<CreateTableColumn> 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
@@ -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>("CreateTableColumn");
+            var tableName = result.Query.GetOneComponent<FromClause>("from").Table;
+            var tableType = result.Query.GetOneComponent<TableCluase>("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
diff --git a/QueryBuilder/Compilers/Enums/DataSource.cs 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
@@ -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
@@ -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;
         }
+
+
+
+
     }
 }