- 修复 MySql8.0.30 无法使用 ExecuteInserted 的问题；#2001

2881099 · 2881099 · commit f861c9da6ea5 · 2025-03-27T23:47:30.000+08:00
diff --git a/Examples/base_entity/Program.cs b/Examples/base_entity/Program.cs
@@ -621,6 +621,8 @@ static void Main(string[] args)
             BaseEntity.Initialization(fsql, () => _asyncUow.Value);
             #endregion
 
+            fsql.Insert(new User1()).ExecuteInserted();
+
             fsql.InsertOrUpdate<AppInfoEntity>().SetSource(new AppInfoEntity { AppID = "03DN8CW8", AppName = "app_01" }).ExecuteAffrows();
             var repo2211 = fsql.GetRepository<AppInfoEntity>();
 
diff --git a/FreeSql/FreeSql.xml b/FreeSql/FreeSql.xml
diff --git a/FreeSql/Interface/Curd/IInsert.cs b/FreeSql/Interface/Curd/IInsert.cs
@@ -156,7 +156,7 @@ public interface IInsert<T1> where T1 : class
         long ExecuteIdentity();
         /// <summary>
         /// 执行SQL语句，返回插入后的记录<para></para>
-        /// 注意：此方法只有 Postgresql/SqlServer/Maridb/Firebird/DuckDB/人大金仓 有效果
+        /// 注意：此方法只有 Postgresql/SqlServer/MySql8.0.30+/Maridb/Firebird/DuckDB/人大金仓 有效果
         /// </summary>
         /// <returns></returns>
         List<T1> ExecuteInserted();
@@ -174,6 +174,11 @@ public interface IInsert<T1> where T1 : class
 #else
         Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
         Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default);
+        /// <summary>
+        /// 执行SQL语句，返回插入后的记录<para></para>
+        /// 注意：此方法只有 Postgresql/SqlServer/MySql8.0.30+/Maridb/Firebird/DuckDB/人大金仓 有效果
+        /// </summary>
+        /// <returns></returns>
         Task<List<T1>> ExecuteInsertedAsync(CancellationToken cancellationToken = default);
 #endif
     }
diff --git a/FreeSql/Internal/CommonProvider/InsertProvider.cs b/FreeSql/Internal/CommonProvider/InsertProvider.cs
@@ -431,7 +431,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)
             if (ss.Length == 1)
             {
                 _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
-                ret = this.RawExecuteInserted();
+                ret = this.InternalExecuteInserted();
                 ClearData();
                 return ret;
             }
@@ -452,7 +452,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)
                     {
                         _source = ss[a];
                         _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
-                        ret.AddRange(this.RawExecuteInserted());
+                        ret.AddRange(this.InternalExecuteInserted());
                     }
                 }
                 else
@@ -469,7 +469,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)
                             {
                                 _source = ss[a];
                                 _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
-                                ret.AddRange(this.RawExecuteInserted());
+                                ret.AddRange(this.InternalExecuteInserted());
                             }
                             _transaction.Commit();
                             _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, CoreErrorStrings.Commit, null));
@@ -525,6 +525,12 @@ protected virtual int RawExecuteAffrows()
 
         protected abstract long RawExecuteIdentity();
         protected abstract List<T1> RawExecuteInserted();
+        private List<T1> InternalExecuteInserted()
+        {
+            var ret = RawExecuteInserted();
+            if (_table.TypeLazySetOrm != null) ret.ForEach(item => _table.TypeLazySetOrm.Invoke(item, new object[] { _orm }));
+            return ret;
+        }
 
         public abstract int ExecuteAffrows();
         public abstract long ExecuteIdentity();
diff --git a/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs b/FreeSql/Internal/CommonProvider/InsertProviderAsync.cs
@@ -189,7 +189,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit
             if (ss.Length == 1)
             {
                 _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));
-                ret = await this.RawExecuteInsertedAsync(cancellationToken);
+                ret = await this.InternalExecuteInsertedAsync(cancellationToken);
                 ClearData();
                 return ret;
             }
@@ -210,7 +210,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit
                     {
                         _source = ss[a]; 
                         _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
-                        ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));
+                        ret.AddRange(await this.InternalExecuteInsertedAsync(cancellationToken));
                     }
                 }
                 else
@@ -227,7 +227,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit
                             {
                                 _source = ss[a];
                                 _batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));
-                                ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));
+                                ret.AddRange(await this.InternalExecuteInsertedAsync(cancellationToken));
                             }
                             _transaction.Commit();
                             _orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, CoreErrorStrings.Commit, null));
@@ -282,6 +282,12 @@ async protected virtual Task<int> RawExecuteAffrowsAsync(CancellationToken cance
 
         protected abstract Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default);
         protected abstract Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default);
+        async private Task<List<T1>> InternalExecuteInsertedAsync(CancellationToken cancellationToken = default)
+        {
+            var ret = await RawExecuteInsertedAsync(cancellationToken);
+            if (_table.TypeLazySetOrm != null) ret.ForEach(item => _table.TypeLazySetOrm.Invoke(item, new object[] { _orm }));
+            return ret;
+        }
 
         public abstract Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);
         public abstract Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default);
diff --git a/FreeSql/Internal/UtilsExpressionTree.cs b/FreeSql/Internal/UtilsExpressionTree.cs
@@ -1752,6 +1752,8 @@ internal static object InternalDataReaderGetValue(CommonUtils commonUtil, DbData
             }
             return dr.GetValue(index);
         }
+        public static object ExecuteReaderToClass(string flagStr, Type typeOrg, int[] indexes, DbDataReader row, int dataIndex, CommonUtils _commonUtils) =>
+            ExecuteArrayRowReadClassOrTuple(flagStr, typeOrg, indexes, row, dataIndex, _commonUtils)?.Value;
         internal static RowInfo ExecuteArrayRowReadClassOrTuple(string flagStr, Type typeOrg, int[] indexes, DbDataReader row, int dataIndex, CommonUtils _commonUtils)
         {
             if (string.IsNullOrEmpty(flagStr)) flagStr = "all";
diff --git a/Providers/FreeSql.Provider.Custom/MySql/Curd/CustomMySqlInsert.cs b/Providers/FreeSql.Provider.Custom/MySql/Curd/CustomMySqlInsert.cs
@@ -89,25 +89,41 @@ protected override List<T1> RawExecuteInserted()
             sb.Append(sql).Append(" RETURNING ");
 
             var colidx = 0;
-            foreach (var col in _table.Columns.Values)
+            var propidx = 0;
+            var props = _table.Type.GetPropertiesDictIgnoreCase();
+            var indexes = new int[props.Count];
+            var sbflag = new StringBuilder().Append("insertedQuery");
+            foreach (var prop in props)
             {
-                if (colidx > 0) sb.Append(", ");
-                sb.Append(_commonUtils.RereadColumn(col, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
-                ++colidx;
+                if (_table.ColumnsByCs.TryGetValue(prop.Key, out var col))
+                {
+                    if (colidx > 0) sb.Append(", ");
+                    sb.Append(_commonUtils.RereadColumn(col, _commonUtils.QuoteSqlName(col.Attribute.Name)));
+                    sbflag.Append(col.Attribute.Name).Append(":").Append(colidx).Append(",");
+                    indexes[propidx] = colidx;
+                    ++colidx;
+                }
+                else
+                    indexes[propidx] = -1;
+                ++propidx;
             }
+            var flag = sbflag.ToString();
             sql = sb.ToString();
             var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params);
             _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
             var ret = new List<T1>();
             Exception exception = null;
             try
             {
-                ret = _orm.Ado.Query<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params);
+                _orm.Ado.ExecuteReader(_connection, _transaction, fetch =>
+                {
+                    ret.Add((T1)Utils.ExecuteReaderToClass(flag, _table.TypeLazy ?? _table.Type, indexes, fetch.Object, 0, _commonUtils));
+                }, CommandType.Text, sql, _commandTimeout, _params);
             }
             catch (Exception ex)
             {
                 exception = ex;
-                throw ex;
+                throw;
             }
             finally
             {
@@ -169,25 +185,42 @@ async protected override Task<List<T1>> RawExecuteInsertedAsync(CancellationToke
             sb.Append(sql).Append(" RETURNING ");
 
             var colidx = 0;
-            foreach (var col in _table.Columns.Values)
+            var propidx = 0;
+            var props = _table.Type.GetPropertiesDictIgnoreCase();
+            var indexes = new int[props.Count];
+            var sbflag = new StringBuilder().Append("insertedQuery");
+            foreach (var prop in props)
             {
-                if (colidx > 0) sb.Append(", ");
-                sb.Append(_commonUtils.RereadColumn(col, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
-                ++colidx;
+                if (_table.ColumnsByCs.TryGetValue(prop.Key, out var col))
+                {
+                    if (colidx > 0) sb.Append(", ");
+                    sb.Append(_commonUtils.RereadColumn(col, _commonUtils.QuoteSqlName(col.Attribute.Name)));
+                    sbflag.Append(col.Attribute.Name).Append(":").Append(colidx).Append(",");
+                    indexes[propidx] = colidx;
+                    ++colidx;
+                }
+                else
+                    indexes[propidx] = -1;
+                ++propidx;
             }
+            var flag = sbflag.ToString();
             sql = sb.ToString();
             var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Insert, sql, _params);
             _orm.Aop.CurdBeforeHandler?.Invoke(this, before);
             var ret = new List<T1>();
             Exception exception = null;
             try
             {
-                ret = await _orm.Ado.QueryAsync<T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, _params, cancellationToken);
+                await _orm.Ado.ExecuteReaderAsync(_connection, _transaction, fetch =>
+                {
+                    ret.Add((T1)Utils.ExecuteReaderToClass(flag, _table.TypeLazy ?? _table.Type, indexes, fetch.Object, 0, _commonUtils));
+                    return Task.FromResult(false);
+                }, CommandType.Text, sql, _commandTimeout, _params);
             }
             catch (Exception ex)
             {
                 exception = ex;
-                throw ex;
+                throw;
             }
             finally
             {
diff --git a/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs b/Providers/FreeSql.Provider.MySql/Curd/MySqlInsert.cs
diff --git a/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs b/Providers/FreeSql.Provider.Odbc/MySql/Curd/OdbcMySqlInsert.cs

Original file line number	Diff line number	Diff line change
`@@ -431,7 +431,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)`
`431`	`431`	`if (ss.Length == 1)`
`432`	`432`	`{`
`433`	`433`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));`
`434`		`- ret = this.RawExecuteInserted();`
	`434`	`+ ret = this.InternalExecuteInserted();`
`435`	`435`	`ClearData();`
`436`	`436`	`return ret;`
`437`	`437`	`}`
`@@ -452,7 +452,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)`
`452`	`452`	`{`
`453`	`453`	`_source = ss[a];`
`454`	`454`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));`
`455`		`- ret.AddRange(this.RawExecuteInserted());`
	`455`	`+ ret.AddRange(this.InternalExecuteInserted());`
`456`	`456`	`}`
`457`	`457`	`}`
`458`	`458`	`else`
`@@ -469,7 +469,7 @@ protected List<T1> SplitExecuteInserted(int valuesLimit, int parameterLimit)`
`469`	`469`	`{`
`470`	`470`	`_source = ss[a];`
`471`	`471`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));`
`472`		`- ret.AddRange(this.RawExecuteInserted());`
	`472`	`+ ret.AddRange(this.InternalExecuteInserted());`
`473`	`473`	`}`
`474`	`474`	`_transaction.Commit();`
`475`	`475`	`_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, CoreErrorStrings.Commit, null));`
`@@ -525,6 +525,12 @@ protected virtual int RawExecuteAffrows()`
`525`	`525`
`526`	`526`	`protected abstract long RawExecuteIdentity();`
`527`	`527`	`protected abstract List<T1> RawExecuteInserted();`
	`528`	`+ private List<T1> InternalExecuteInserted()`
	`529`	`+ {`
	`530`	`+ var ret = RawExecuteInserted();`
	`531`	`+ if (_table.TypeLazySetOrm != null) ret.ForEach(item => _table.TypeLazySetOrm.Invoke(item, new object[] { _orm }));`
	`532`	`+ return ret;`
	`533`	`+ }`
`528`	`534`
`529`	`535`	`public abstract int ExecuteAffrows();`
`530`	`536`	`public abstract long ExecuteIdentity();`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit`
`189`	`189`	`if (ss.Length == 1)`
`190`	`190`	`{`
`191`	`191`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, 1, 1));`
`192`		`- ret = await this.RawExecuteInsertedAsync(cancellationToken);`
	`192`	`+ ret = await this.InternalExecuteInsertedAsync(cancellationToken);`
`193`	`193`	`ClearData();`
`194`	`194`	`return ret;`
`195`	`195`	`}`
`@@ -210,7 +210,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit`
`210`	`210`	`{`
`211`	`211`	`_source = ss[a];`
`212`	`212`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));`
`213`		`- ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));`
	`213`	`+ ret.AddRange(await this.InternalExecuteInsertedAsync(cancellationToken));`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`	`else`
`@@ -227,7 +227,7 @@ async protected virtual Task<List<T1>> SplitExecuteInsertedAsync(int valuesLimit`
`227`	`227`	`{`
`228`	`228`	`_source = ss[a];`
`229`	`229`	`_batchProgress?.Invoke(new BatchProgressStatus<T1>(_source, a + 1, ss.Length));`
`230`		`- ret.AddRange(await this.RawExecuteInsertedAsync(cancellationToken));`
	`230`	`+ ret.AddRange(await this.InternalExecuteInsertedAsync(cancellationToken));`
`231`	`231`	`}`
`232`	`232`	`_transaction.Commit();`
`233`	`233`	`_orm.Aop.TraceAfterHandler?.Invoke(this, new Aop.TraceAfterEventArgs(transBefore, CoreErrorStrings.Commit, null));`
`@@ -282,6 +282,12 @@ async protected virtual Task<int> RawExecuteAffrowsAsync(CancellationToken cance`
`282`	`282`
`283`	`283`	`protected abstract Task<long> RawExecuteIdentityAsync(CancellationToken cancellationToken = default);`
`284`	`284`	`protected abstract Task<List<T1>> RawExecuteInsertedAsync(CancellationToken cancellationToken = default);`
	`285`	`+ async private Task<List<T1>> InternalExecuteInsertedAsync(CancellationToken cancellationToken = default)`
	`286`	`+ {`
	`287`	`+ var ret = await RawExecuteInsertedAsync(cancellationToken);`
	`288`	`+ if (_table.TypeLazySetOrm != null) ret.ForEach(item => _table.TypeLazySetOrm.Invoke(item, new object[] { _orm }));`
	`289`	`+ return ret;`
	`290`	`+ }`
`285`	`291`
`286`	`292`	`public abstract Task<int> ExecuteAffrowsAsync(CancellationToken cancellationToken = default);`
`287`	`293`	`public abstract Task<long> ExecuteIdentityAsync(CancellationToken cancellationToken = default);`
Original file line number	Diff line number	Diff line change
`@@ -1752,6 +1752,8 @@ internal static object InternalDataReaderGetValue(CommonUtils commonUtil, DbData`
`1752`	`1752`	`}`
`1753`	`1753`	`return dr.GetValue(index);`
`1754`	`1754`	`}`
	`1755`	`+ public static object ExecuteReaderToClass(string flagStr, Type typeOrg, int[] indexes, DbDataReader row, int dataIndex, CommonUtils _commonUtils) =>`
	`1756`	`+ ExecuteArrayRowReadClassOrTuple(flagStr, typeOrg, indexes, row, dataIndex, _commonUtils)?.Value;`
`1755`	`1757`	`internal static RowInfo ExecuteArrayRowReadClassOrTuple(string flagStr, Type typeOrg, int[] indexes, DbDataReader row, int dataIndex, CommonUtils _commonUtils)`
`1756`	`1758`	`{`
`1757`	`1759`	`if (string.IsNullOrEmpty(flagStr)) flagStr = "all";`