!74 添加GaussDB驱动与测试项目

Merge pull request !74 from Rookie/master

Src/Asp.NetCore2/GaussTest/GaussDBTest.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SqlSugar.GaussCore\SqlSugar.GaussDBCore.csproj" />
+  </ItemGroup>
+
+</Project>

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!");

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
+    {
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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<IDataParameter>();
+                    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<SqlSugarException> 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<Type, OpenGaussDbType> ArrayMapping = new Dictionary<Type, OpenGaussDbType>()
+        {
+            { 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},
+        };
+    }
+}

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<T> : PostgreSQLInserttable<T> where T : class, new()
+    {
+    }
+}

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<T> : QueryableProvider<T>
+    {
+        public override ISugarQueryable<T> With(string withString)
+        {
+            return this;
+        }
+
+        public override ISugarQueryable<T> PartitionBy(string groupFileds)
+        {
+            this.GroupBy(groupFileds);
+            return this;
+        }
+    }
+    public class GaussDBQueryable<T, T2> : QueryableProvider<T, T2>
+    {
+        public new ISugarQueryable<T, T2> With(string withString)
+        {
+            return this;
+        }
+    }
+    public class GaussDBQueryable<T, T2, T3> : QueryableProvider<T, T2, T3>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4> : QueryableProvider<T, T2, T3, T4>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5> : QueryableProvider<T, T2, T3, T4, T5>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6> : QueryableProvider<T, T2, T3, T4, T5, T6>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7> : QueryableProvider<T, T2, T3, T4, T5, T6, T7>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7, T8> : QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> : QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> : QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+    {
+
+    }
+    public class GaussDBQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+    {
+
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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<string , OpenGaussDbType> PgSqlType = UtilMethods.EnumToDictionary<OpenGaussDbType>();
+
+        public async Task<int> ExecuteBulkCopyAsync(DataTable dt)
+        {
+            List<string> lsColNames = new List<string>();
+            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<DbColumnInfo> columns)
+        {
+            if (conn.State == ConnectionState.Closed)
+                conn.Open();
+            List<ColumnView> columnViews = new List<ColumnView>();
+            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; }
+        }
+
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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
+    {
+    }
+}

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
+{
+    /// <summary>
+    /// 数据填充器
+    /// </summary>
+    public class GaussDBDataAdapter : IDataAdapter
+    {
+        private OpenGaussCommand command;
+        private string sql;
+        private OpenGaussConnection _sqlConnection;
+
+        /// <summary>
+        /// SqlDataAdapter
+        /// </summary>
+        /// <param name="command"></param>
+        public GaussDBDataAdapter(OpenGaussCommand command)
+        {
+            this.command = command;
+        }
+
+        public GaussDBDataAdapter()
+        {
+
+        }
+
+        /// <summary>
+        /// SqlDataAdapter
+        /// </summary>
+        /// <param name="sql"></param>
+        /// <param name="_sqlConnection"></param>
+        public GaussDBDataAdapter(string sql, OpenGaussConnection _sqlConnection)
+        {
+            this.sql = sql;
+            this._sqlConnection = _sqlConnection;
+        }
+
+        /// <summary>
+        /// SelectCommand
+        /// </summary>
+        public OpenGaussCommand SelectCommand
+        {
+            get
+            {
+                if (this.command == null)
+                {
+                    this.command = new OpenGaussCommand(this.sql, this._sqlConnection);
+                }
+                return this.command;
+            }
+            set
+            {
+                this.command = value;
+            }
+        }
+
+        /// <summary>
+        /// Fill
+        /// </summary>
+        /// <param name="dt"></param>
+        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();
+        }
+
+        /// <summary>
+        /// Fill
+        /// </summary>
+        /// <param name="ds"></param>
+        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());
+            }
+        }
+    }
+}

Src/Asp.NetCore2/SqlSugar.GaussCore/SqlSugar.GaussDBCore.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SqlSugar\SqlSugar.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="OpenGauss.NET">
+      <HintPath>OpenGauss.NET.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
+</Project>

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<int, int>);
+        internal static Type DicIS = typeof(KeyValuePair<int, string>);
+        internal static Type DicSi = typeof(KeyValuePair<string, int>);
+        internal static Type DicSS = typeof(KeyValuePair<string, string>);
+        internal static Type DicOO = typeof(KeyValuePair<object, object>);
+        internal static Type DicSo = typeof(KeyValuePair<string, object>);
+        internal static Type DicArraySS = typeof(Dictionary<string, string>);
+        internal static Type DicArraySO = typeof(Dictionary<string, object>);
+
+        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"
+        };
+    }
+}

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<T>(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<object> 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<object> thisValue)
+        {
+            if (thisValue == null || thisValue.Count() == 0) return false;
+            return true;
+        }
+
+        public static bool IsValuable(this IEnumerable<KeyValuePair<string, string>> 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+$");
+        }
+
+        /// <returns></returns>
+        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;
+        }
+    }
+}

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}