diff --git a/Program/Program.cs b/Program/Program.cs index 9b4c2845..bdc7940d 100644 --- a/Program/Program.cs +++ b/Program/Program.cs @@ -1,114 +1,83 @@ using System; using System.Collections.Generic; +using Microsoft.Extensions.DependencyInjection; 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 SqlKata.Compilers.Abstractions; +using SqlKata.Compilers.DDLCompiler.CreateTableBuilders.DBSpecificQueries; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; +using SqlKata.Contract.CreateTable.DbTableSpecific; +using SqlKata.DbTypes.DbColumn; +using SqlKata.DbTypes.Enums; namespace Program { class Program { - private class Loan - { - public string Id { get; set; } - public string Name { get; set; } - public List Installments { get; set; } = new List(); - } - - private class Installment - { - public string Id { get; set; } - public string LoanId { get; set; } - public int DaysCount { get; set; } - } - static void Main(string[] args) { - 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); - } + 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").DropTable(); + //var query = new Query("Users").Truncate(); + //var query = CreateTable(); + //var query = CreateTableAs(); + + /* 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 void log(Compiler compiler, Query query) + private static Query CreateTableAs() { - var compiled = compiler.Compile(query); - Console.WriteLine(compiled.ToString()); - Console.WriteLine(JsonConvert.SerializeObject(compiled.Bindings)); + 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 QueryFactory SqlLiteQueryFactory() + private static Query CreateTable() { - var compiler = new SqliteCompiler(); - - var connection = new SQLiteConnection("Data Source=Demo.db"); - - var db = new QueryFactory(connection, compiler); - - db.Logger = result => + var query = new Query("Users").CreateTable(new List() { - 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++) + new() + { + ColumnName = "id", + ColumnDbType = new OracleDBColumn() + { + OracleDbType = OracleDbType.Int32 + }, + IsAutoIncrement = true, + IsNullable = false, + IsPrimaryKey = true, + IsUnique = false, + }, + new() { - db.Statement("insert into accounts(name, currency_id, balance, created_at) values(@name, @currency, @balance, @date)", new + ColumnName = "FullName", + ColumnDbType = new OracleDBColumn() { - name = $"Account {i}", - currency = "USD", - balance = 100 * i * 1.1, - date = DateTime.UtcNow, - }); + OracleDbType = OracleDbType.Varchar2, + Length = 30, + //Collation = "Arabiv_Ci_100_Ai" + }, + IsAutoIncrement = false, + IsNullable = false, + IsPrimaryKey = false, + IsUnique = true, } - - } - - 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; + }, TableType.Temporary); + return query; } - } } diff --git a/Program/Program.csproj b/Program/Program.csproj index 6341ecef..2e44c542 100644 --- a/Program/Program.csproj +++ b/Program/Program.csproj @@ -10,12 +10,13 @@ + Exe false - netcoreapp2.0 + net6.0 diff --git a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs index aded9fd1..5bdc8adf 100644 --- a/QueryBuilder.Tests/Infrastructure/TestCompiler.cs +++ b/QueryBuilder.Tests/Infrastructure/TestCompiler.cs @@ -15,6 +15,16 @@ 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(); + } } class TestSqlServerCompiler : SqlServerCompiler diff --git a/QueryBuilder/Clauses/ColumnClause.cs b/QueryBuilder/Clauses/ColumnClause.cs index dd51a85e..c76b789b 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 @@ -30,6 +32,35 @@ public override AbstractClause Clone() } } + public class CreateTableColumn : AbstractClause + { + public string ColumnName { get; set; } + public BaseDBColumn 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 string Collate { get; set; } + public override AbstractClause Clone() + { + return new CreateTableColumn + { + Component= Component, + ColumnDbType= ColumnDbType, + ColumnName= ColumnName, + IsAutoIncrement= IsAutoIncrement, + IsPrimaryKey= IsPrimaryKey, + IsUnique= IsUnique, + IsIdentity= IsIdentity, + IsNullable= IsNullable, + Collate = Collate + }; + } + } + + + /// /// Represents column clause calculated using query. /// @@ -85,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/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/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/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/Clauses/TableCluase.cs b/QueryBuilder/Clauses/TableCluase.cs new file mode 100644 index 00000000..fdf07b9d --- /dev/null +++ b/QueryBuilder/Clauses/TableCluase.cs @@ -0,0 +1,17 @@ +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, + Component = Component + }; + } + } +} 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 aa15c789..38c59652 100644 --- a/QueryBuilder/Compilers/Compiler.cs +++ b/QueryBuilder/Compilers/Compiler.cs @@ -2,12 +2,15 @@ using System.Collections.Generic; using System.Linq; using System.Text; +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers { - public partial class Compiler + 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; } = "\""; @@ -17,7 +20,6 @@ public 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"; @@ -27,18 +29,23 @@ protected Compiler() _compileConditionMethodsProvider = new ConditionsCompilerProvider(this); } + protected Compiler(IDDLCompiler ddlCompiler) : this() + { + DdlCompiler = ddlCompiler; + } + public virtual string EngineCode { get; } /// /// 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; } @@ -124,6 +131,26 @@ protected virtual SqlResult CompileRaw(Query query) { ctx = CompileDeleteQuery(query); } + else if (query.Method == "CreateTable") + { + ctx = CompileCreateTable(query); + } + else if (query.Method == "CreateTableAs") + { + ctx = CompileCreateTableAs(query); + } + else if (query.Method == "Drop") + { + ctx = CompileDropTable(query); + } + else if (query.Method == "Truncate") + { + ctx = CompileTruncateTable(query); + } + else if (query.Method == "selectInto") + { + ctx = CompileSelectIntoQuery(query); + } else { if (query.Method == "aggregate") @@ -134,7 +161,6 @@ protected virtual SqlResult CompileRaw(Query query) query = TransformAggregateQuery(query); } - ctx = CompileSelectQuery(query); } @@ -149,6 +175,37 @@ 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); + } + + protected virtual SqlResult CompileDropTable(Query query) + { + return DdlCompiler.CompileDropTable(query); + } + + 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 @@ -227,6 +284,12 @@ protected virtual SqlResult CompileSelectQuery(Query query) return ctx; } + /// + /// gets create table query. each db has its own implementation + /// + /// + /// + protected abstract SqlResult CompileCreateTable(Query query); protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) { var ctx = new SqlResult(); @@ -295,7 +358,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}"; @@ -868,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/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs new file mode 100644 index 00000000..f7bbe036 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IColumnCompiler.cs @@ -0,0 +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,DataSource dataSource); + } +} 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/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/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 new file mode 100644 index 00000000..7d23bf4f --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ICreateTableQueryCompiler.cs @@ -0,0 +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,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 new file mode 100644 index 00000000..352681eb --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IDDLCompiler.cs @@ -0,0 +1,12 @@ +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + 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/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/IPrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IPrimaryKeyCompiler.cs new file mode 100644 index 00000000..6067d50e --- /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 + { + string CompilePrimaryKey(List createTableColumnClauses); + } +} 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 new file mode 100644 index 00000000..87562a47 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/Abstractions/ISqlCreateCommandUtil.cs @@ -0,0 +1,12 @@ +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +namespace SqlKata.Compilers.DDLCompiler.Abstractions +{ + internal interface ISqlCreateCommandUtil + { + DataSource DataSource { get; } + string AutoIncrementIdentityCommandGenerator(); + string GetTempTableClause(); + } +} 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/Abstractions/IUniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/Abstractions/IUniqueConstraintCompiler.cs new file mode 100644 index 00000000..a11ac603 --- /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 +{ + internal interface IUniqueConstraintCompiler + { + string CompileUniqueConstraints(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..15c87d4b --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/ColumnCompilers/ColumnCompiler.cs @@ -0,0 +1,41 @@ +using System.Collections.Generic; +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 ISqlCreateCommandProvider _sqlCreateCommandProvider; + + public ColumnCompiler(ISqlCreateCommandProvider sqlCreateCommandProvider) + { + this._sqlCreateCommandProvider = sqlCreateCommandProvider; + } + public string CompileCreateTableColumns(List createTableColumnClauses,DataSource dataSource) + { + var queryString = new StringBuilder(); + 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 columnClause in createTableColumnClauses) + { + var nullOrNot = columnClause.IsNullable ? "NULL " : "NOT NULL "; + var collate = columnClause.Collate == null ? "" : $"Collate {columnClause.Collate}"; + if (columnClause.IsIdentity || columnClause.IsAutoIncrement) + { + queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {_sqlCreateCommandProvider.GetSqlCreateCommandUtil(dataSource).AutoIncrementIdentityCommandGenerator()},\n"); + continue; + } + queryString.Append($"{columnClause.ColumnName} {columnClause.ColumnDbType.GetDBType()} {collate} {nullOrNot},\n"); + } + + return queryString.ToString(); + } + } +} 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/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/CreateTableQueryUtils/MySqlCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs new file mode 100644 index 00000000..d6b90ab1 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/MySqlCreateCommandUtil.cs @@ -0,0 +1,21 @@ +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 "; + } + + public string GetTempTableClause() + { + return "TEMPORARY"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs new file mode 100644 index 00000000..6720fb38 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/OracleCreateCommandUtil.cs @@ -0,0 +1,19 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.CreateTableQueryUtils +{ + internal class OracleCreateCommandUtil : ISqlCreateCommandUtil + { + public DataSource DataSource { get; } = DataSource.Oracle; + + 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 new file mode 100644 index 00000000..cfa93681 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/PostgresqlCreateCommandUtil.cs @@ -0,0 +1,20 @@ +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 ""; + } + public string GetTempTableClause() + { + return "TEMPORARY"; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs new file mode 100644 index 00000000..bf3f4805 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqlServerCreateCommandUtil.cs @@ -0,0 +1,20 @@ +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) "; + } + public string GetTempTableClause() + { + return ""; + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs new file mode 100644 index 00000000..e8bb0fd5 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/CreateTableQueryUtils/SqliteCreateCommandUtil.cs @@ -0,0 +1,21 @@ +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 "; + } + + 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/PrimaryKeyCompilers/PrimaryKeyCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.cs new file mode 100644 index 00000000..5ba277d6 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/PrimaryKeyCompilers/PrimaryKeyCompiler.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.PrimaryKeyCompilers +{ + internal class PrimaryKeyCompiler : IPrimaryKeyCompiler + { + 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/CreateTable/MySqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs new file mode 100644 index 00000000..d60a51ee --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/MySqlCreateTableFormatFactory.cs @@ -0,0 +1,15 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable +{ + 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/CreateTable/OracleCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs new file mode 100644 index 00000000..b6b6c17a --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/OracleCreateTableFormatFactory.cs @@ -0,0 +1,16 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable +{ + 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/CreateTable/PostgresqlCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs new file mode 100644 index 00000000..f8f32e87 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/PostgresqlCreateTableFormatFactory.cs @@ -0,0 +1,15 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable +{ + 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/CreateTable/SqlServerCreateTableFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs new file mode 100644 index 00000000..ee249b48 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTable/SqlServerCreateTableFormatFactory.cs @@ -0,0 +1,15 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Factories.CreateTable +{ + 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/Factories/CreateTableAs/CreateTableAsFormatFactory.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Factories/CreateTableAs/CreateTableAsFormatFactory.cs new file mode 100644 index 00000000..cb98e67f --- /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/CreateTable/MySqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/MySqlCreateQueryFormatFiller.cs new file mode 100644 index 00000000..9b37c2d1 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/MySqlCreateQueryFormatFiller.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.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, ISqlCreateCommandProvider createCommandProvider) + { + _columnCompiler = columnCompiler; + _primaryKeyCompiler = primaryKeyCompiler; + _uniqueConstraintCompiler = uniqueConstraintCompiler; + _createCommandUtil = createCommandProvider.GetSqlCreateCommandUtil(DataSource.MySql); + } + + 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 ? _createCommandUtil.GetTempTableClause() : ""; + return string.Format(queryFormat, + tempString, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.MySql), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs new file mode 100644 index 00000000..b9b94188 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/OracleCreateQueryFormatFiller.cs @@ -0,0 +1,54 @@ +using SqlKata.Clauses; +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.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, + 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) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempString = tableType == TableType.Temporary ? _sqlCreateCommandUtil.GetTempTableClause() : ""; + + 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,DataSource.Oracle), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses), + onCommitBehaviour + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs new file mode 100644 index 00000000..e9b31e25 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/PostgresqlCreateQueryFormatFiller.cs @@ -0,0 +1,41 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; +using SqlKata.Contract.CreateTable; + +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, 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) + { + var createTableColumnClauses = query.GetComponents("CreateTableColumn"); + var tableName = query.GetOneComponent("from").Table; + var tableType = query.GetOneComponent("TableType").TableType; + var tempString = tableType == TableType.Temporary ? _sqlCreateCommandUtil.GetTempTableClause() : ""; + return string.Format(queryFormat, + tempString, + tableName, + _columnCompiler.CompileCreateTableColumns(createTableColumnClauses,DataSource.Postgresql), + _primaryKeyCompiler.CompilePrimaryKey(createTableColumnClauses), + _uniqueConstraintCompiler.CompileUniqueConstraints(createTableColumnClauses) + ); + } + } +} diff --git a/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs new file mode 100644 index 00000000..d8735a34 --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/QueryFormat/Fillers/CreateTable/SqlServerCreateQueryFormatFiller.cs @@ -0,0 +1,32 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler.CreateTableBuilders.QueryFormat.Fillers.CreateTable +{ + 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,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/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs new file mode 100644 index 00000000..664b4ecb --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/CreateTableBuilders/UniqueConstraintCompilers/UniqueConstraintCompiler.cs @@ -0,0 +1,21 @@ +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 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 new file mode 100644 index 00000000..21a5bbdf --- /dev/null +++ b/QueryBuilder/Compilers/DDLCompiler/DDLCompiler.cs @@ -0,0 +1,65 @@ +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + +namespace SqlKata.Compilers.DDLCompiler +{ + 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, ITruncateTableQueryFactory truncateTableQueryFactory, + IDropTableQueryFactory dropTableQueryFactory) + { + _createTableQueryCompiler = createTableQueryCompiler; + _createTableAsCompiler = createTableAsCompiler; + _truncateTableQueryFactory = truncateTableQueryFactory; + _dropTableQueryFactory = dropTableQueryFactory; + } + + + public SqlResult CompileCreateTable(Query query, DataSource dataSource) + { + var result = new SqlResult() + { + Query = query.Clone(), + RawSql = _createTableQueryCompiler.CompileCreateTable(query, dataSource) + }; + return result; + } + + public SqlResult CompileCreateTableAs(Query query, DataSource dataSource, string compiledSelectQuery) + { + var result = new SqlResult + { + 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) + }; + 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/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/Compilers/Enums/DataSource.cs b/QueryBuilder/Compilers/Enums/DataSource.cs new file mode 100644 index 00000000..cf55fd50 --- /dev/null +++ b/QueryBuilder/Compilers/Enums/DataSource.cs @@ -0,0 +1,12 @@ +namespace SqlKata.Compilers.Enums +{ + public enum DataSource + { + SqlServer, + Oracle, + Postgresql, + MySql, + Firebird, + Sqlite + } +} diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs index 61ab9547..bbf0cbbb 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; @@ -116,5 +124,15 @@ 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 4729125b..f4e117ab 100644 --- a/QueryBuilder/Compilers/MySqlCompiler.cs +++ b/QueryBuilder/Compilers/MySqlCompiler.cs @@ -1,13 +1,23 @@ +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; + namespace SqlKata.Compilers { public class MySqlCompiler : Compiler { + 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) @@ -45,5 +55,16 @@ public override string CompileLimit(SqlResult ctx) return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}"; } + + 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 610ec20d..d1033276 100644 --- a/QueryBuilder/Compilers/OracleCompiler.cs +++ b/QueryBuilder/Compilers/OracleCompiler.cs @@ -1,13 +1,20 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; -using System.Text.RegularExpressions; +using System.Text; +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class OracleCompiler : Compiler { + public OracleCompiler(IDDLCompiler ddlCompiler) : this() + { + DdlCompiler = ddlCompiler; + } + public OracleCompiler() { ColumnAsKeyword = ""; @@ -20,6 +27,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) @@ -172,5 +185,19 @@ protected override SqlResult CompileRemainingInsertClauses( ctx.RawSql += " SELECT 1 FROM DUAL"; return ctx; } + + protected override SqlResult CompileCreateTable(Query query) + { + 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 3b45d0e6..b58be879 100644 --- a/QueryBuilder/Compilers/PostgresCompiler.cs +++ b/QueryBuilder/Compilers/PostgresCompiler.cs @@ -1,10 +1,18 @@ using System; using System.Linq; +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class PostgresCompiler : Compiler { + public PostgresCompiler(IDDLCompiler ddlCompiler) : this() + { + DdlCompiler = ddlCompiler; + } + public PostgresCompiler() { LastId = "SELECT lastval() AS id"; @@ -95,5 +103,17 @@ 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/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 0202f0f1..c3278d6d 100644 --- a/QueryBuilder/Compilers/SqlServerCompiler.cs +++ b/QueryBuilder/Compilers/SqlServerCompiler.cs @@ -1,9 +1,17 @@ using System.Linq; +using SqlKata.Clauses; +using SqlKata.Compilers.DDLCompiler.Abstractions; +using SqlKata.Compilers.Enums; namespace SqlKata.Compilers { public class SqlServerCompiler : Compiler { + public SqlServerCompiler(IDDLCompiler ddlCompiler) : this() + { + DdlCompiler = ddlCompiler; + } + public SqlServerCompiler() { OpeningIdentifier = "["; @@ -14,6 +22,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)) @@ -186,5 +200,10 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc) return ctx; } + + protected override SqlResult CompileCreateTable(Query query) + { + return DdlCompiler.CompileCreateTable(query,DataSource.SqlServer); + } } } diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs index 1401dd35..ed3d36c5 100644 --- a/QueryBuilder/Compilers/SqliteCompiler.cs +++ b/QueryBuilder/Compilers/SqliteCompiler.cs @@ -1,9 +1,21 @@ using System.Collections.Generic; +using SqlKata.Compilers.DDLCompiler.Abstractions; namespace SqlKata.Compilers { public class SqliteCompiler : Compiler { + + 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; } = "\""; @@ -63,5 +75,15 @@ 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/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..1291b090 --- /dev/null +++ b/QueryBuilder/Contract/CreateTable/DbTableSpecific/OracleDbTableExtensions.cs @@ -0,0 +1,8 @@ +namespace SqlKata.Contract.CreateTable.DbTableSpecific +{ + public class OracleDbTableExtensions : CreateDbTableExtension + { + public bool OnCommitPreserveRows { get; set; } + public string hint { get; set; } + } +} diff --git a/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs new file mode 100644 index 00000000..da22887d --- /dev/null +++ b/QueryBuilder/Contract/CreateTable/TableColumnDefinitionDto.cs @@ -0,0 +1,15 @@ +using SqlKata.DbTypes.DbColumn; + +namespace SqlKata.Contract.CreateTable +{ + public class TableColumnDefinitionDto + { + public string ColumnName { get; set; } + public BaseDBColumn 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/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/DbTypes/DbColumn/BaseDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs new file mode 100644 index 00000000..a560fe12 --- /dev/null +++ b/QueryBuilder/DbTypes/DbColumn/BaseDBColumn.cs @@ -0,0 +1,30 @@ +using System.Text; + +namespace SqlKata.DbTypes.DbColumn +{ + public abstract class BaseDBColumn + { + public int? Length { get; set; } + public int? Precision { get; set; } + public string Collation { 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..489f6dfb --- /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().Replace("_"," ")); + 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..5fbbb73f --- /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().Replace("_", " ")); + 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..9cfb04ae --- /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().Replace("_", " ")); + 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..060f3ef0 --- /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().Replace("_", " ")); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs b/QueryBuilder/DbTypes/DbColumn/SqliteDBColumn.cs new file mode 100644 index 00000000..bc59d106 --- /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().Replace("_", " ")); + AddLengthAndPrecisionToType(stringBuilder); + return stringBuilder.ToString(); + } + } +} diff --git a/QueryBuilder/DbTypes/Enums/MySqlDbType.cs b/QueryBuilder/DbTypes/Enums/MySqlDbType.cs new file mode 100644 index 00000000..6981def9 --- /dev/null +++ b/QueryBuilder/DbTypes/Enums/MySqlDbType.cs @@ -0,0 +1,37 @@ +namespace SqlKata.DbTypes.Enums +{ + 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/DbTypes/Enums/OracleDbType.cs b/QueryBuilder/DbTypes/Enums/OracleDbType.cs new file mode 100644 index 00000000..87c5d0f0 --- /dev/null +++ b/QueryBuilder/DbTypes/Enums/OracleDbType.cs @@ -0,0 +1,41 @@ +namespace SqlKata.DbTypes.Enums +{ + 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/DbTypes/Enums/PostgresqlDbType.cs b/QueryBuilder/DbTypes/Enums/PostgresqlDbType.cs new file mode 100644 index 00000000..84d37ac0 --- /dev/null +++ b/QueryBuilder/DbTypes/Enums/PostgresqlDbType.cs @@ -0,0 +1,57 @@ +namespace SqlKata.DbTypes.Enums +{ + 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/DbTypes/Enums/SqlServerDbType.cs b/QueryBuilder/DbTypes/Enums/SqlServerDbType.cs new file mode 100644 index 00000000..65290d65 --- /dev/null +++ b/QueryBuilder/DbTypes/Enums/SqlServerDbType.cs @@ -0,0 +1,37 @@ +namespace SqlKata.DbTypes.Enums +{ + 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/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 + + } +} 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) + { + } + } +} 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/KataDependencyInjection.cs b/QueryBuilder/KataDependencyInjection.cs new file mode 100644 index 00000000..2ba31eec --- /dev/null +++ b/QueryBuilder/KataDependencyInjection.cs @@ -0,0 +1,73 @@ +using Microsoft.Extensions.DependencyInjection; +using SqlKata.Compilers.Abstractions; +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.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.DeleteDdl; +using SqlKata.Compilers.DDLCompiler.Providers; +using SqlKata.Compilers.Providers; +using SqlKata.Compilers.Providers.Factories; + +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(); + 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(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + services.AddSingleton(); + + 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 new file mode 100644 index 00000000..462da2a4 --- /dev/null +++ b/QueryBuilder/Query.CreateTable.cs @@ -0,0 +1,81 @@ +using SqlKata.Clauses; +using SqlKata.Contract.CreateTable; +using System.Collections.Generic; +using System.Linq; +using SqlKata.Contract.CreateTable.DbTableSpecific; +using SqlKata.Exceptions.CreateTableQuery; + +namespace SqlKata +{ + public partial class Query + { + public Query CreateTable(IEnumerable columns,TableType tableType = TableType.Permanent,CreateDbTableExtension createDbTableExtension = null) + { + Method = "CreateTable"; + + AddTableTypeComponent(tableType); + + AddDbSpecificCreateTableComponent(createDbTableExtension); + + columns.ToList().ForEach(column => + { + AddComponent("CreateTableColumn",new CreateTableColumn() + { + Component = "CreateTableColumn", + ColumnName = column.ColumnName, + ColumnDbType = column.ColumnDbType, + IsNullable = column.IsNullable, + IsUnique = column.IsUnique, + IsPrimaryKey = column.IsPrimaryKey, + IsAutoIncrement = column.IsAutoIncrement, + IsIdentity = column.IsIdentity, + Collate = column.ColumnDbType.Collation + }); + }); + + return this; + } + + 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"); + } + + AddDbSpecificCreateTableComponent(createDbTableExtension); + AddTableTypeComponent(tableType); + + AddComponent("CreateTableAsQuery", new CreateTableAsClause + { + SelectQuery = selectQuery, + Component = "CreateTableAsQuery" + }); + + 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" + }); + } + + + } +} 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; + } + + } +} 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"; diff --git a/QueryBuilder/QueryBuilder.csproj b/QueryBuilder/QueryBuilder.csproj index 5ce65d65..e0a2453c 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 @@ -32,5 +34,6 @@ +