diff --git a/Src/Asp.NetCore2/GaussTest/GaussDBTest.csproj b/Src/Asp.NetCore2/GaussTest/GaussDBTest.csproj new file mode 100644 index 000000000..36ae1cbff --- /dev/null +++ b/Src/Asp.NetCore2/GaussTest/GaussDBTest.csproj @@ -0,0 +1,14 @@ + + + + Exe + net6.0 + enable + enable + + + + + + + diff --git a/Src/Asp.NetCore2/GaussTest/Program.cs b/Src/Asp.NetCore2/GaussTest/Program.cs new file mode 100644 index 000000000..3da093ed3 --- /dev/null +++ b/Src/Asp.NetCore2/GaussTest/Program.cs @@ -0,0 +1,39 @@ +using SqlSugar; +using System.Data; + + +SqlSugar.InstanceFactory.CustomNamespace = "SqlSugar.GaussDB"; +SqlSugar.InstanceFactory.CustomDbName = "GaussDB"; +SqlSugar.InstanceFactory.CustomDllName = "SqlSugar.GaussDBCore"; +//创建DB +var db = new SqlSugarClient(new ConnectionConfig() +{ + ConnectionString = "PORT=5432;DATABASE=SqlSugar5Demo;HOST=localhost;PASSWORD=postgres;USER ID=postgres", + DbType = SqlSugar.DbType.Custom, + IsAutoCloseConnection = true, + MoreSettings = new ConnMoreSettings() + { + DatabaseModel = SqlSugar.DbType.OpenGauss + } +}, db => +{ + + + db.Aop.OnLogExecuting = (x, y) => + { + Console.WriteLine(x); + }; + +}); + +db.Open(); +db.Close(); + +var dt = db.Ado.GetDataTable("SELECT * from tb_user limit 10"); + +dt.AsEnumerable().ToList().ForEach(r => +{ + Console.WriteLine(r[0].ToString()); +}); + +Console.WriteLine("Hello, World!"); \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/CodeFirst/GaussDBCodeFirst.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/CodeFirst/GaussDBCodeFirst.cs new file mode 100644 index 000000000..66f112348 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/CodeFirst/GaussDBCodeFirst.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBCodeFirst : PostgreSQLCodeFirst + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbBind/GaussDBDbBind.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbBind/GaussDBDbBind.cs new file mode 100644 index 000000000..b1e77b43e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbBind/GaussDBDbBind.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBDbBind : PostgreSQLDbBind + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbFirst/GaussDBDbFirst.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbFirst/GaussDBDbFirst.cs new file mode 100644 index 000000000..5ad5ebeb4 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbFirst/GaussDBDbFirst.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBDbFirst : PostgreSQLDbFirst + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbMaintenance/GaussDBDbMaintenance.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbMaintenance/GaussDBDbMaintenance.cs new file mode 100644 index 000000000..905b52798 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/DbMaintenance/GaussDBDbMaintenance.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBDbMaintenance: PostgreSQLDbMaintenance + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/GaussDBProvider.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/GaussDBProvider.cs new file mode 100644 index 000000000..3a177c1b3 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/GaussDBProvider.cs @@ -0,0 +1,253 @@ +using Dm; +using Npgsql; +using NpgsqlTypes; +using OpenGauss.NET; +using OpenGauss.NET.Types; +using SqlSugar.GaussDBCore; +using SqlSugar.GaussDBCore.Tools; +using System; +using System.Collections.Generic; +using System.Data; +using System.Data.Common; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + public class GaussDBProvider : PostgreSQLProvider + { + public override IDbConnection Connection + { + get + { + if (base._DbConnection == null) + { + try + { + var npgsqlConnectionString = base.Context.CurrentConnectionConfig.ConnectionString; + base._DbConnection = new OpenGaussConnection(npgsqlConnectionString); + } + catch (Exception ex) + { + throw; + } + } + return base._DbConnection; + } + set + { + base._DbConnection = value; + } + } + + //public override void BeginTran(string transactionName) + //{ + // throw new NotImplementedException(); + //} + + //public override void BeginTran(IsolationLevel iso, string transactionName) + //{ + // throw new NotImplementedException(); + //} + + public override IDataAdapter GetAdapter() + { + return new GaussDBDataAdapter(); + } + + public override DbCommand GetCommand(string sql, SugarParameter[] parameters) + { + OpenGaussCommand sqlCommand = new OpenGaussCommand(sql, (OpenGaussConnection)this.Connection); + sqlCommand.CommandType = this.CommandType; + sqlCommand.CommandTimeout = this.CommandTimeOut; + if (this.Transaction != null) + { + sqlCommand.Transaction = (OpenGaussTransaction)this.Transaction; + } + if (parameters.HasValue()) + { + IDataParameter[] ipars = ToIDbDataParameter(parameters); + sqlCommand.Parameters.AddRange((OpenGaussParameter[])ipars); + } + CheckConnection(); + return sqlCommand; + } + + public override void SetCommandToAdapter(IDataAdapter adapter, DbCommand command) + { + ((GaussDBDataAdapter)adapter).SelectCommand = (OpenGaussCommand)command; + } + + public override IDataParameter[] ToIDbDataParameter(params SugarParameter[] parameters) + { + if (parameters == null || parameters.Length == 0) return null; + OpenGaussParameter[] result = new OpenGaussParameter[parameters.Length]; + int index = 0; + var isVarchar = this.Context.IsVarchar(); + foreach (var parameter in parameters) + { + if (parameter.DbType == System.Data.DbType.Int64 && parameter.Value?.Equals("Result%") == true) + { + parameter.DbType = System.Data.DbType.AnsiString; + } + UNumber(parameter); + if (parameter.Value == null) parameter.Value = DBNull.Value; + if (parameter.Value is System.Data.SqlTypes.SqlDateTime && parameter.DbType == System.Data.DbType.AnsiString) + { + parameter.DbType = System.Data.DbType.DateTime; + parameter.Value = DBNull.Value; + } + var sqlParameter = new OpenGaussParameter(); + sqlParameter.ParameterName = parameter.ParameterName; + sqlParameter.Size = parameter.Size; + sqlParameter.Value = parameter.Value; + sqlParameter.DbType = parameter.DbType; + sqlParameter.Direction = parameter.Direction; + if (parameter.IsJson) + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Json; + } + if (parameter.IsArray) + { + Array(parameter, sqlParameter); + } + if (sqlParameter.Direction == 0) + { + sqlParameter.Direction = ParameterDirection.Input; + } + result[index] = sqlParameter; + if (sqlParameter.Direction.IsIn(ParameterDirection.Output, ParameterDirection.InputOutput, ParameterDirection.ReturnValue)) + { + if (this.OutputParameters == null) this.OutputParameters = new List(); + this.OutputParameters.RemoveAll(it => it.ParameterName == sqlParameter.ParameterName); + this.OutputParameters.Add(sqlParameter); + } + if (isVarchar && sqlParameter.DbType == System.Data.DbType.String) + { + sqlParameter.DbType = System.Data.DbType.AnsiString; + } + else if (sqlParameter.Value is DateTime && sqlParameter.DbType == System.Data.DbType.AnsiString) + { + sqlParameter.DbType = System.Data.DbType.DateTime; + } + ++index; + if (parameter.CustomDbType != null && parameter.CustomDbType is OpenGaussDbType) + { + sqlParameter.OpenGaussDbType = ((OpenGaussDbType)parameter.CustomDbType); + } + } + return result; + } + + private static void Array(SugarParameter parameter, OpenGaussParameter sqlParameter) + { + // sqlParameter.Value = this.Context.Utilities.SerializeObject(sqlParameter.Value); + var type = sqlParameter.Value.GetType(); + if (ArrayMapping.ContainsKey(type)) + { + sqlParameter.OpenGaussDbType = ArrayMapping[type] | OpenGaussDbType.Array; + } + else if (type == DBNull.Value.GetType()) + { + DbNullParametrerArray(parameter, sqlParameter); + + } + else + { + Check.Exception(true, sqlParameter.Value.GetType().Name + " No Support"); + } + } + + private static void DbNullParametrerArray(SugarParameter parameter, OpenGaussParameter sqlParameter) + { + if (parameter.DbType.IsIn(System.Data.DbType.Int32)) + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Integer | OpenGaussDbType.Array; + } + else if (parameter.DbType.IsIn(System.Data.DbType.Int16)) + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Smallint | OpenGaussDbType.Array; + } + else if (parameter.DbType.IsIn(System.Data.DbType.Int64)) + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Bigint | OpenGaussDbType.Array; + } + else if (parameter.DbType.IsIn(System.Data.DbType.Guid)) + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Uuid | OpenGaussDbType.Array; + } + else + { + sqlParameter.OpenGaussDbType = OpenGaussDbType.Text | OpenGaussDbType.Array; + } + } + + private static void UNumber(SugarParameter parameter) + { + if (parameter.DbType == System.Data.DbType.UInt16) + { + parameter.DbType = System.Data.DbType.Int16; + parameter.Value = Convert.ToInt16(parameter.Value); + } + else if (parameter.DbType == System.Data.DbType.UInt32) + { + parameter.DbType = System.Data.DbType.Int32; + parameter.Value = Convert.ToInt32(parameter.Value); + } + else if (parameter.DbType == System.Data.DbType.UInt64) + { + parameter.DbType = System.Data.DbType.Int64; + parameter.Value = Convert.ToInt64(parameter.Value); + } + if (parameter.Value is uint) + { + parameter.Value = Convert.ToInt32(parameter.Value); + } + else if (parameter.Value is ulong) + { + parameter.Value = Convert.ToInt64(parameter.Value); + } + } + public override Action ErrorEvent => it => + { + if (base.ErrorEvent != null) + { + base.ErrorEvent(it); + } + if (it.Message != null && it.Message.StartsWith("42883: function uuid_generate_v4() does not exist")) + { + Check.ExceptionEasy(it.Message, $"使用uuid_generate_v4()函数需要创建 CREATE EXTENSION IF NOT EXISTS pgcrypto;CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\" "); + } + }; + + static readonly Dictionary ArrayMapping = new Dictionary() + { + { typeof(int[]),OpenGaussDbType.Integer}, + { typeof(short[]),OpenGaussDbType.Smallint}, + { typeof(long[]),OpenGaussDbType.Bigint}, + { typeof(decimal[]),OpenGaussDbType.Numeric}, + { typeof(char[]),OpenGaussDbType.Text}, + { typeof(byte[]),OpenGaussDbType.Bytea}, + { typeof(bool[]),OpenGaussDbType.Boolean}, + {typeof(DateTime[]),OpenGaussDbType.Date}, + {typeof(float[]),OpenGaussDbType.Real}, + {typeof(Guid[]),OpenGaussDbType.Uuid}, + + + { typeof(int?[]),OpenGaussDbType.Integer}, + { typeof(short?[]),OpenGaussDbType.Smallint}, + { typeof(long?[]),OpenGaussDbType.Bigint}, + { typeof(decimal?[]),OpenGaussDbType.Numeric}, + { typeof(char?[]),OpenGaussDbType.Text}, + { typeof(byte?[]),OpenGaussDbType.Bytea}, + { typeof(bool?[]),OpenGaussDbType.Boolean}, + {typeof(DateTime?[]),OpenGaussDbType.Date}, + {typeof(Guid?[]),OpenGaussDbType.Uuid}, + + + { typeof(string[]), OpenGaussDbType.Text}, + {typeof(float?[]),OpenGaussDbType.Real}, + }; + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Insertable/GaussDBInserttable.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Insertable/GaussDBInserttable.cs new file mode 100644 index 000000000..89aceacd5 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Insertable/GaussDBInserttable.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBInserttable : PostgreSQLInserttable where T : class, new() + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Queryable/GaussDBQueryable.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Queryable/GaussDBQueryable.cs new file mode 100644 index 000000000..19bae4f19 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/Queryable/GaussDBQueryable.cs @@ -0,0 +1,69 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + public class GaussDBQueryable : QueryableProvider + { + public override ISugarQueryable With(string withString) + { + return this; + } + + public override ISugarQueryable PartitionBy(string groupFileds) + { + this.GroupBy(groupFileds); + return this; + } + } + public class GaussDBQueryable : QueryableProvider + { + public new ISugarQueryable With(string withString) + { + return this; + } + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } + public class GaussDBQueryable : QueryableProvider + { + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBBuilder.cs new file mode 100644 index 000000000..f3328149f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBBuilder.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBBuilder : PostgreSQLBuilder + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBDeleteBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBDeleteBuilder.cs new file mode 100644 index 000000000..e25186df0 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBDeleteBuilder.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBDeleteBuilder: PostgreSQLDeleteBuilder + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBExpressionContext.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBExpressionContext.cs new file mode 100644 index 000000000..c7a6aceef --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBExpressionContext.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBExpressionContext : PostgreSQLExpressionContext + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBFastBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBFastBuilder.cs new file mode 100644 index 000000000..65aaaa597 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBFastBuilder.cs @@ -0,0 +1,136 @@ +using Npgsql; +using NpgsqlTypes; +using OpenGauss.NET; +using OpenGauss.NET.Types; +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBFastBuilder : FastBuilder, IFastBuilder + { + public static Dictionary PgSqlType = UtilMethods.EnumToDictionary(); + + public async Task ExecuteBulkCopyAsync(DataTable dt) + { + List lsColNames = new List(); + for (int i = 0; i < dt.Columns.Count; i++) + { + lsColNames.Add($"\"{dt.Columns[i].ColumnName}\""); + } + string copyString = $"COPY {dt.TableName} ( {string.Join(",", lsColNames)} ) FROM STDIN (FORMAT BINARY)"; + if (this.Context?.CurrentConnectionConfig?.MoreSettings?.DatabaseModel == DbType.OpenGauss) + { + copyString = copyString.Replace("(FORMAT BINARY)", "(FORMAT 'BINARY')"); + } + OpenGaussConnection conn = (OpenGaussConnection)this.Context.Ado.Connection; + var columns = this.Context.DbMaintenance.GetColumnInfosByTableName(this.FastEntityInfo.DbTableName); + try + { + var identityColumnInfo = this.FastEntityInfo.Columns.FirstOrDefault(it => it.IsIdentity); + if (identityColumnInfo != null) + { + throw new Exception("PgSql bulkcopy no support identity"); + } + BulkCopy(dt, copyString, conn, columns); + } + catch (Exception ex) + { + throw ex; + } + finally + { + base.CloseDb(); + } + return await Task.FromResult(dt.Rows.Count); + } + + private void BulkCopy(DataTable dt, string copyString, OpenGaussConnection conn, List columns) + { + if (conn.State == ConnectionState.Closed) + conn.Open(); + List columnViews = new List(); + foreach (DataColumn item in dt.Columns) + { + ColumnView result = new ColumnView(); + result.DbColumnInfo = columns.FirstOrDefault(it => it.DbColumnName.Equals(item.ColumnName, StringComparison.OrdinalIgnoreCase)); + result.DataColumn = item; + result.EntityColumnInfo = this.FastEntityInfo.Columns.FirstOrDefault(it => it.DbColumnName.Equals(item.ColumnName, StringComparison.OrdinalIgnoreCase)); + var key = result.DbColumnInfo?.DataType?.ToLower(); + if (result.DbColumnInfo == null) + { + result.Type = null; + } + else if (PgSqlType.ContainsKey(key)) + { + result.Type = PgSqlType[key]; + } + else if (key?.First() == '_') + { + if (key == "_int4") + { + result.Type = OpenGaussDbType.Array | OpenGaussDbType.Integer; + } + else if (key == "_int2") + { + result.Type = OpenGaussDbType.Array | OpenGaussDbType.Smallint; + } + else if (key == "_int8") + { + result.Type = OpenGaussDbType.Array | OpenGaussDbType.Bigint; + } + else + { + var type = PgSqlType[key.Substring(1)]; + result.Type = OpenGaussDbType.Array | type; + } + } + else + { + result.Type = null; + } + columnViews.Add(result); + } + using (var writer = conn.BeginBinaryImport(copyString)) + { + foreach (DataRow row in dt.Rows) + { + writer.StartRow(); + foreach (var column in columnViews) + { + var value = row[column.DataColumn.ColumnName]; + if (value == null) + { + value = DBNull.Value; + } + //else if (value is double&&this.Context?.CurrentConnectionConfig?.MoreSettings?.DatabaseModel==null) + //{ + // column.Type = NpgsqlDbType.Double; + //} + if (column.Type == null) + { + writer.Write(value); + } + else + { + writer.Write(value, column.Type.Value); + } + } + } + writer.Complete(); + } + } + public class ColumnView + { + public DataColumn DataColumn { get; set; } + public EntityColumnInfo EntityColumnInfo { get; set; } + public DbColumnInfo DbColumnInfo { get; set; } + public OpenGaussDbType? Type { get; set; } + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBInsertBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBInsertBuilder.cs new file mode 100644 index 000000000..71ac4bd45 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBInsertBuilder.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBInsertBuilder : PostgreSQLInsertBuilder + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBQueryBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBQueryBuilder.cs new file mode 100644 index 000000000..8db6e36e7 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBQueryBuilder.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBQueryBuilder : PostgreSQLQueryBuilder + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBUpdateBuilder.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBUpdateBuilder.cs new file mode 100644 index 000000000..433ce4743 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDB/SqlBuilder/GaussDBUpdateBuilder.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDB +{ + internal class GaussDBUpdateBuilder: PostgreSQLUpdateBuilder + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDBDataAdapter.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDBDataAdapter.cs new file mode 100644 index 000000000..2dc65db49 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/GaussDBDataAdapter.cs @@ -0,0 +1,146 @@ +using OpenGauss; +using OpenGauss.NET; +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDBCore +{ + /// + /// 数据填充器 + /// + public class GaussDBDataAdapter : IDataAdapter + { + private OpenGaussCommand command; + private string sql; + private OpenGaussConnection _sqlConnection; + + /// + /// SqlDataAdapter + /// + /// + public GaussDBDataAdapter(OpenGaussCommand command) + { + this.command = command; + } + + public GaussDBDataAdapter() + { + + } + + /// + /// SqlDataAdapter + /// + /// + /// + public GaussDBDataAdapter(string sql, OpenGaussConnection _sqlConnection) + { + this.sql = sql; + this._sqlConnection = _sqlConnection; + } + + /// + /// SelectCommand + /// + public OpenGaussCommand SelectCommand + { + get + { + if (this.command == null) + { + this.command = new OpenGaussCommand(this.sql, this._sqlConnection); + } + return this.command; + } + set + { + this.command = value; + } + } + + /// + /// Fill + /// + /// + public void Fill(DataTable dt) + { + if (dt == null) + { + dt = new DataTable(); + } + var columns = dt.Columns; + var rows = dt.Rows; + using (OpenGaussDataReader dr = command.ExecuteReader()) + { + for (int i = 0; i < dr.FieldCount; i++) + { + string name = dr.GetName(i).Trim(); + if (!columns.Contains(name)) + columns.Add(new DataColumn(name, dr.GetFieldType(i))); + else + { + columns.Add(new DataColumn(name + i, dr.GetFieldType(i))); + } + } + + while (dr.Read()) + { + DataRow daRow = dt.NewRow(); + for (int i = 0; i < columns.Count; i++) + { + daRow[columns[i].ColumnName] = dr.GetValue(i); + } + dt.Rows.Add(daRow); + } + } + dt.AcceptChanges(); + } + + /// + /// Fill + /// + /// + public void Fill(DataSet ds) + { + if (ds == null) + { + ds = new DataSet(); + } + using (OpenGaussDataReader dr = command.ExecuteReader()) + { + do + { + var dt = new DataTable(); + var columns = dt.Columns; + var rows = dt.Rows; + for (int i = 0; i < dr.FieldCount; i++) + { + string name = dr.GetName(i).Trim(); + if (!columns.Contains(name)) + columns.Add(new DataColumn(name, dr.GetFieldType(i))); + else + { + columns.Add(new DataColumn(name + i, dr.GetFieldType(i))); + } + } + + while (dr.Read()) + { + DataRow daRow = dt.NewRow(); + for (int i = 0; i < columns.Count; i++) + { + daRow[columns[i].ColumnName] = dr.GetValue(i); + } + dt.Rows.Add(daRow); + } + dt.AcceptChanges(); + ds.Tables.Add(dt); + } while (dr.NextResult()); + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/OpenGauss.NET.dll b/Src/Asp.NetCore2/SqlSugar.GaussCore/OpenGauss.NET.dll new file mode 100644 index 000000000..0c338693a Binary files /dev/null and b/Src/Asp.NetCore2/SqlSugar.GaussCore/OpenGauss.NET.dll differ diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/SqlSugar.GaussDBCore.csproj b/Src/Asp.NetCore2/SqlSugar.GaussCore/SqlSugar.GaussDBCore.csproj new file mode 100644 index 000000000..f50dde065 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/SqlSugar.GaussDBCore.csproj @@ -0,0 +1,19 @@ + + + + net6.0 + enable + enable + + + + + + + + + OpenGauss.NET.dll + + + + diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/UtilConstants.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/UtilConstants.cs new file mode 100644 index 000000000..d0c9db4e8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/UtilConstants.cs @@ -0,0 +1,75 @@ +using System; +using System.Collections.Generic; +using System.Dynamic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDBCore.Tools +{ + internal static class UtilConstants + { + public const string Dot = "."; + public const char DotChar = '.'; + internal const string Space = " "; + internal const char SpaceChar = ' '; + internal const string AssemblyName = "SqlSugar"; + internal const string ReplaceKey = "{662E689B-17A1-4D06-9D27-F29EAB8BC3D6}"; + internal const string ReplaceCommaKey = "{112A689B-17A1-4A06-9D27-A39EAB8BC3D5}"; + + internal static Type IntType = typeof(int); + internal static Type LongType = typeof(long); + internal static Type GuidType = typeof(Guid); + internal static Type BoolType = typeof(bool); + internal static Type BoolTypeNull = typeof(bool?); + internal static Type ByteType = typeof(Byte); + internal static Type ObjType = typeof(object); + internal static Type DobType = typeof(double); + internal static Type FloatType = typeof(float); + internal static Type ShortType = typeof(short); + internal static Type DecType = typeof(decimal); + internal static Type StringType = typeof(string); + internal static Type DateType = typeof(DateTime); + internal static Type DateTimeOffsetType = typeof(DateTimeOffset); + internal static Type TimeSpanType = typeof(TimeSpan); + internal static Type ByteArrayType = typeof(byte[]); + internal static Type ModelType = typeof(ModelContext); + internal static Type DynamicType = typeof(ExpandoObject); + internal static Type Dicii = typeof(KeyValuePair); + internal static Type DicIS = typeof(KeyValuePair); + internal static Type DicSi = typeof(KeyValuePair); + internal static Type DicSS = typeof(KeyValuePair); + internal static Type DicOO = typeof(KeyValuePair); + internal static Type DicSo = typeof(KeyValuePair); + internal static Type DicArraySS = typeof(Dictionary); + internal static Type DicArraySO = typeof(Dictionary); + + public static Type SugarType = typeof(SqlSugarProvider); + + + internal static Type[] NumericalTypes = new Type[] + { + typeof(int), + typeof(uint), + typeof(byte), + typeof(sbyte), + typeof(long), + typeof(ulong), + typeof(short), + typeof(ushort), + }; + + + internal static string[] DateTypeStringList = new string[] + { + "Year", + "Month", + "Day", + "Hour", + "Second" , + "Minute", + "Millisecond", + "Date" + }; + } +} diff --git a/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/ValidateExtensions.cs b/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/ValidateExtensions.cs new file mode 100644 index 000000000..270dcfd02 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar.GaussCore/Tools/ValidateExtensions.cs @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; + +namespace SqlSugar.GaussDBCore.Tools +{ + internal static class ValidateExtensions + { + public static bool IsInRange(this int thisValue, int begin, int end) + { + return thisValue >= begin && thisValue <= end; + } + + public static bool IsInRange(this DateTime thisValue, DateTime begin, DateTime end) + { + return thisValue >= begin && thisValue <= end; + } + + public static bool IsIn(this T thisValue, params T[] values) + { + return values.Contains(thisValue); + } + + public static bool IsContainsIn(this string thisValue, params string[] inValues) + { + return inValues.Any(it => thisValue.Contains(it)); + } + + public static bool IsNullOrEmpty(this object thisValue) + { + if (thisValue == null || thisValue == DBNull.Value) return true; + return thisValue.ToString() == ""; + } + + public static bool IsNullOrEmpty(this Guid? thisValue) + { + if (thisValue == null) return true; + return thisValue == Guid.Empty; + } + + public static bool IsNullOrEmpty(this Guid thisValue) + { + if (thisValue == null) return true; + return thisValue == Guid.Empty; + } + + public static bool IsNullOrEmpty(this IEnumerable thisValue) + { + if (thisValue == null || thisValue.Count() == 0) return true; + return false; + } + + public static bool HasValue(this object thisValue) + { + if (thisValue == null || thisValue == DBNull.Value) return false; + return thisValue.ToString() != ""; + } + + public static bool HasValue(this IEnumerable thisValue) + { + if (thisValue == null || thisValue.Count() == 0) return false; + return true; + } + + public static bool IsValuable(this IEnumerable> thisValue) + { + if (thisValue == null || thisValue.Count() == 0) return false; + return true; + } + + public static bool IsZero(this object thisValue) + { + return (thisValue == null || thisValue.ToString() == "0"); + } + + public static bool IsInt(this object thisValue) + { + if (thisValue == null) return false; + return Regex.IsMatch(thisValue.ToString(), @"^\d+$"); + } + + /// + public static bool IsNoInt(this object thisValue) + { + if (thisValue == null) return true; + return !Regex.IsMatch(thisValue.ToString(), @"^\d+$"); + } + + public static bool IsMoney(this object thisValue) + { + if (thisValue == null) return false; + double outValue = 0; + return double.TryParse(thisValue.ToString(), out outValue); + } + public static bool IsGuid(this object thisValue) + { + if (thisValue == null) return false; + Guid outValue = Guid.Empty; + return Guid.TryParse(thisValue.ToString(), out outValue); + } + + public static bool IsDate(this object thisValue) + { + if (thisValue == null) return false; + DateTime outValue = DateTime.MinValue; + return DateTime.TryParse(thisValue.ToString(), out outValue); + } + + public static bool IsEamil(this object thisValue) + { + if (thisValue == null) return false; + return Regex.IsMatch(thisValue.ToString(), @"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"); + } + + public static bool IsMobile(this object thisValue) + { + if (thisValue == null) return false; + return Regex.IsMatch(thisValue.ToString(), @"^\d{11}$"); + } + + public static bool IsTelephone(this object thisValue) + { + if (thisValue == null) return false; + return System.Text.RegularExpressions.Regex.IsMatch(thisValue.ToString(), @"^(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}$"); + + } + + public static bool IsIDcard(this object thisValue) + { + if (thisValue == null) return false; + return System.Text.RegularExpressions.Regex.IsMatch(thisValue.ToString(), @"^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$"); + } + + public static bool IsFax(this object thisValue) + { + if (thisValue == null) return false; + return System.Text.RegularExpressions.Regex.IsMatch(thisValue.ToString(), @"^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$"); + } + + public static bool IsMatch(this object thisValue, string pattern) + { + if (thisValue == null) return false; + Regex reg = new Regex(pattern); + return reg.IsMatch(thisValue.ToString()); + } + public static bool IsAnonymousType(this Type type) + { + string typeName = type.Name; + return typeName.Contains("<>") && typeName.Contains("__") && typeName.Contains("AnonymousType"); + } + public static bool IsCollectionsList(this string thisValue) + { + return (thisValue + "").StartsWith("System.Collections.Generic.List") || (thisValue + "").StartsWith("System.Collections.Generic.IEnumerable"); + } + public static bool IsStringArray(this string thisValue) + { + return (thisValue + "").IsMatch(@"System\.[a-z,A-Z,0-9]+?\[\]"); + } + public static bool IsEnumerable(this string thisValue) + { + return (thisValue + "").StartsWith("System.Linq.Enumerable"); + } + + public static Type StringType = typeof(string); + + public static bool IsClass(this Type thisValue) + { + return thisValue != StringType && thisValue.IsEntity() && thisValue != UtilConstants.ByteArrayType; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugarCore.sln b/Src/Asp.NetCore2/SqlSugarCore.sln index d731ffc15..ce2dd7b44 100644 --- a/Src/Asp.NetCore2/SqlSugarCore.sln +++ b/Src/Asp.NetCore2/SqlSugarCore.sln @@ -90,6 +90,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DB2CoreTest", "DB2CoreTest\ EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SqlSugar.Db2Core", "SqlSugar.Db2Core\SqlSugar.Db2Core.csproj", "{F706204F-2FC4-5112-646F-28D498E56AF4}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SqlSugar.GaussDBCore", "SqlSugar.GaussCore\SqlSugar.GaussDBCore.csproj", "{15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GaussDBTest", "GaussTest\GaussDBTest.csproj", "{F17886C5-60CB-4B69-9B0A-7E07E073B385}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -580,6 +584,30 @@ Global {F706204F-2FC4-5112-646F-28D498E56AF4}.Release|ARM32.Build.0 = Release|Any CPU {F706204F-2FC4-5112-646F-28D498E56AF4}.Release|x86.ActiveCfg = Release|Any CPU {F706204F-2FC4-5112-646F-28D498E56AF4}.Release|x86.Build.0 = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|ARM32.ActiveCfg = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|ARM32.Build.0 = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|x86.ActiveCfg = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Debug|x86.Build.0 = Debug|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|Any CPU.Build.0 = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|ARM32.ActiveCfg = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|ARM32.Build.0 = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|x86.ActiveCfg = Release|Any CPU + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB}.Release|x86.Build.0 = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|ARM32.ActiveCfg = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|ARM32.Build.0 = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|x86.ActiveCfg = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Debug|x86.Build.0 = Debug|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|Any CPU.Build.0 = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|ARM32.ActiveCfg = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|ARM32.Build.0 = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|x86.ActiveCfg = Release|Any CPU + {F17886C5-60CB-4B69-9B0A-7E07E073B385}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -597,6 +625,7 @@ Global {B86EC97E-13F2-422B-8CA0-46181D40DEF2} = {88992AAF-146B-4253-9AD7-493E8F415B57} {B3C4B993-C33E-48AF-955F-EB801774FBE8} = {88992AAF-146B-4253-9AD7-493E8F415B57} {F706204F-2FC4-5112-646F-28D498E56AF4} = {88992AAF-146B-4253-9AD7-493E8F415B57} + {15CB3CFF-E99D-4A79-8F6F-D9175CC2F7CB} = {88992AAF-146B-4253-9AD7-493E8F415B57} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {230A85B9-54F1-41B1-B1DA-80086581B2B4}