拆分 FreeSql 按需引用

Providers/FreeSql.Provider.Oracle/Curd/OracleDelete.cs

@@ -0,0 +1,22 @@
+using FreeSql.Internal;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FreeSql.Oracle.Curd {
+
+	class OracleDelete<T1> : Internal.CommonProvider.DeleteProvider<T1> where T1 : class {
+		public OracleDelete(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere)
+			: base(orm, commonUtils, commonExpression, dywhere) {
+		}
+
+		public override List<T1> ExecuteDeleted() {
+			throw new NotImplementedException();
+		}
+		public override Task<List<T1>> ExecuteDeletedAsync() {
+			throw new NotImplementedException();
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/Curd/OracleInsert.cs

@@ -0,0 +1,185 @@
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using Oracle.ManagedDataAccess.Client;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FreeSql.Oracle.Curd {
+
+	class OracleInsert<T1> : Internal.CommonProvider.InsertProvider<T1> where T1 : class {
+		public OracleInsert(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression)
+			: base(orm, commonUtils, commonExpression) {
+		}
+
+		public override int ExecuteAffrows() => base.SplitExecuteAffrows(500, 999);
+		public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(500, 999);
+		public override long ExecuteIdentity() => base.SplitExecuteIdentity(500, 999);
+		public override Task<long> ExecuteIdentityAsync() => base.SplitExecuteIdentityAsync(500, 999);
+		public override List<T1> ExecuteInserted() => base.SplitExecuteInserted(500, 999);
+		public override Task<List<T1>> ExecuteInsertedAsync() => base.SplitExecuteInsertedAsync(500, 999);
+
+
+		public override string ToSql() {
+			if (_source == null || _source.Any() == false) return null;
+			var sb = new StringBuilder();
+			sb.Append("INSERT ");
+			if (_source.Count > 1) sb.Append("ALL");
+
+			_identCol = null;
+			var sbtb = new StringBuilder();
+			sbtb.Append("INTO ");
+			sbtb.Append(_commonUtils.QuoteSqlName(_tableRule?.Invoke(_table.DbName) ?? _table.DbName)).Append("(");
+			var colidx = 0;
+			foreach (var col in _table.Columns.Values) {
+				if (col.Attribute.IsIdentity == true) {
+					_identCol = col;
+					continue;
+				}
+				if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false) {
+					if (colidx > 0) sbtb.Append(", ");
+					sbtb.Append(_commonUtils.QuoteSqlName(col.Attribute.Name));
+					++colidx;
+				}
+			}
+			sbtb.Append(") ");
+
+			_params = _noneParameter ? new DbParameter[0] : new DbParameter[colidx * _source.Count];
+			var specialParams = new List<DbParameter>();
+			var didx = 0;
+			foreach (var d in _source) {
+				if (_source.Count > 1) sb.Append("\r\n");
+				sb.Append(sbtb);
+				sb.Append("VALUES");
+				sb.Append("(");
+				var colidx2 = 0;
+				foreach (var col in _table.Columns.Values) {
+					if (col.Attribute.IsIdentity == false && _ignore.ContainsKey(col.Attribute.Name) == false) {
+						if (colidx2 > 0) sb.Append(", ");
+						object val = col.GetMapValue(d);
+						if (col.Attribute.IsPrimary && col.Attribute.MapType.NullableTypeOrThis() == typeof(Guid) && (val == null || (Guid)val == Guid.Empty))
+							col.SetMapValue(d, val = FreeUtil.NewMongodbId());
+						if (_noneParameter)
+							sb.Append(_commonUtils.GetNoneParamaterSqlValue(specialParams, col.Attribute.MapType, val));
+						else {
+							sb.Append(_commonUtils.QuoteWriteParamter(col.Attribute.MapType, _commonUtils.QuoteParamterName($"{col.CsName}_{didx}")));
+							_params[didx * colidx + colidx2] = _commonUtils.AppendParamter(null, $"{col.CsName}_{didx}", col.Attribute.MapType, val);
+						}
+						++colidx2;
+					}
+				}
+				sb.Append(")");
+				++didx;
+			}
+			if (_source.Count > 1) sb.Append("\r\n SELECT 1 FROM DUAL");
+			return sb.ToString();
+		}
+
+		ColumnInfo _identCol;
+		protected override long RawExecuteIdentity() {
+			var sql = this.ToSql();
+			if (string.IsNullOrEmpty(sql)) return 0;
+
+			long ret = 0;
+			Exception exception = null;
+			Aop.CurdBeforeEventArgs before = null;
+
+			if (_identCol == null || _source.Count > 1) {
+				before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
+				_orm.Aop.CurdBefore?.Invoke(this, before);
+				try {
+					ret = _orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, _params);
+				} catch (Exception ex) {
+					exception = ex;
+					throw ex;
+				} finally {
+					var after = new Aop.CurdAfterEventArgs(before, exception, ret);
+					_orm.Aop.CurdAfter?.Invoke(this, after);
+				}
+				this.ClearData();
+				return 0;
+			}
+			var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
+			var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.Attribute.MapType, 0) as OracleParameter;
+			identParam.Direction = ParameterDirection.Output;
+			sql = $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}";
+			var dbParms = _params.Concat(new[] { identParam }).ToArray();
+			before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, dbParms);
+			_orm.Aop.CurdBefore?.Invoke(this, before);
+			try {
+				_orm.Ado.ExecuteNonQuery(_connection, _transaction, CommandType.Text, sql, dbParms);
+				long.TryParse(string.Concat(identParam.Value), out ret);
+			} catch (Exception ex) {
+				exception = ex;
+				throw ex;
+			} finally {
+				var after = new Aop.CurdAfterEventArgs(before, exception, ret);
+				_orm.Aop.CurdAfter?.Invoke(this, after);
+			}
+			this.ClearData();
+			return ret;
+		}
+		async protected override Task<long> RawExecuteIdentityAsync() {
+			var sql = this.ToSql();
+			if (string.IsNullOrEmpty(sql)) return 0;
+
+			long ret = 0;
+			Exception exception = null;
+			Aop.CurdBeforeEventArgs before = null;
+
+			if (_identCol == null || _source.Count > 1) {
+				before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, _params);
+				_orm.Aop.CurdBefore?.Invoke(this, before);
+				try {
+					ret = await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, _params);
+				} catch (Exception ex) {
+					exception = ex;
+					throw ex;
+				} finally {
+					var after = new Aop.CurdAfterEventArgs(before, exception, ret);
+					_orm.Aop.CurdAfter?.Invoke(this, after);
+				}
+				this.ClearData();
+				return 0;
+			}
+			var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
+			var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.Attribute.MapType, 0) as OracleParameter;
+			identParam.Direction = ParameterDirection.Output;
+			sql = $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}";
+			var dbParms = _params.Concat(new[] { identParam }).ToArray();
+			before = new Aop.CurdBeforeEventArgs(_table.Type, Aop.CurdType.Insert, sql, dbParms);
+			_orm.Aop.CurdBefore?.Invoke(this, before);
+			try {
+				await _orm.Ado.ExecuteNonQueryAsync(_connection, _transaction, CommandType.Text, sql, dbParms);
+				long.TryParse(string.Concat(identParam.Value), out ret);
+			} catch (Exception ex) {
+				exception = ex;
+				throw ex;
+			} finally {
+				var after = new Aop.CurdAfterEventArgs(before, exception, ret);
+				_orm.Aop.CurdAfter?.Invoke(this, after);
+			}
+			this.ClearData();
+			return ret;
+		}
+
+		protected override List<T1> RawExecuteInserted() {
+			var sql = this.ToSql();
+			if (string.IsNullOrEmpty(sql)) return new List<T1>();
+
+			this.RawExecuteAffrows();
+			return _source;
+		}
+		async protected override Task<List<T1>> RawExecuteInsertedAsync() {
+			var sql = this.ToSql();
+			if (string.IsNullOrEmpty(sql)) return new List<T1>();
+
+			await this.RawExecuteAffrowsAsync();
+			return _source;
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/Curd/OracleSelect.cs

@@ -0,0 +1,140 @@
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace FreeSql.Oracle.Curd {
+
+	class OracleSelect<T1> : FreeSql.Internal.CommonProvider.Select1Provider<T1> where T1 : class {
+
+		internal static string ToSqlStatic(CommonUtils _commonUtils, string _select, bool _distinct, string field, StringBuilder _join, StringBuilder _where, string _groupby, string _having, string _orderby, int _skip, int _limit, List<SelectTableInfo> _tables, Func<Type, string, string> tableRuleInvoke, IFreeSql _orm) {
+			if (_orm.CodeFirst.IsAutoSyncStructure)
+				_orm.CodeFirst.SyncStructure(_tables.Select(a => a.Table.Type).ToArray());
+
+			var sb = new StringBuilder();
+			var sbnav = new StringBuilder();
+			sb.Append(_select);
+			if (_distinct) sb.Append("DISTINCT ");
+			sb.Append(field);
+			if (string.IsNullOrEmpty(_orderby) && _skip > 0) sb.Append(", ROWNUM AS \"__rownum__\"");
+			sb.Append(" \r\nFROM ");
+			var tbsjoin = _tables.Where(a => a.Type != SelectTableInfoType.From).ToArray();
+			var tbsfrom = _tables.Where(a => a.Type == SelectTableInfoType.From).ToArray();
+			for (var a = 0; a < tbsfrom.Length; a++) {
+				sb.Append(_commonUtils.QuoteSqlName(tableRuleInvoke(tbsfrom[a].Table.Type, tbsfrom[a].Table.DbName))).Append(" ").Append(tbsfrom[a].Alias);
+				if (tbsjoin.Length > 0) {
+					//如果存在 join 查询，则处理 from t1, t2 改为 from t1 inner join t2 on 1 = 1
+					for (var b = 1; b < tbsfrom.Length; b++) {
+						sb.Append(" \r\nLEFT JOIN ").Append(_commonUtils.QuoteSqlName(tableRuleInvoke(tbsfrom[b].Table.Type, tbsfrom[b].Table.DbName))).Append(" ").Append(tbsfrom[b].Alias);
+						if (string.IsNullOrEmpty(tbsfrom[b].NavigateCondition) && string.IsNullOrEmpty(tbsfrom[b].On)) sb.Append(" ON 1 = 1");
+						else sb.Append(" ON ").Append(tbsfrom[b].NavigateCondition ?? tbsfrom[b].On);
+					}
+					break;
+				} else {
+					if (!string.IsNullOrEmpty(tbsfrom[a].NavigateCondition)) sbnav.Append(" AND (").Append(tbsfrom[a].NavigateCondition).Append(")");
+					if (!string.IsNullOrEmpty(tbsfrom[a].On)) sbnav.Append(" AND (").Append(tbsfrom[a].On).Append(")");
+				}
+				if (a < tbsfrom.Length - 1) sb.Append(", ");
+			}
+			foreach (var tb in tbsjoin) {
+				if (tb.Type == SelectTableInfoType.Parent) continue;
+				switch (tb.Type) {
+					case SelectTableInfoType.LeftJoin:
+						sb.Append(" \r\nLEFT JOIN ");
+						break;
+					case SelectTableInfoType.InnerJoin:
+						sb.Append(" \r\nINNER JOIN ");
+						break;
+					case SelectTableInfoType.RightJoin:
+						sb.Append(" \r\nRIGHT JOIN ");
+						break;
+				}
+				sb.Append(_commonUtils.QuoteSqlName(tableRuleInvoke(tb.Table.Type, tb.Table.DbName))).Append(" ").Append(tb.Alias).Append(" ON ").Append(tb.On ?? tb.NavigateCondition);
+				if (!string.IsNullOrEmpty(tb.On) && !string.IsNullOrEmpty(tb.NavigateCondition)) sbnav.Append(" AND (").Append(tb.NavigateCondition).Append(")");
+			}
+			if (_join.Length > 0) sb.Append(_join);
+
+			sbnav.Append(_where);
+			foreach (var tb in _tables) {
+				if (tb.Type == SelectTableInfoType.Parent) continue;
+				if (string.IsNullOrEmpty(tb.Table.SelectFilter) == false)
+					sbnav.Append(" AND (").Append(tb.Table.SelectFilter.Replace("a.", $"{tb.Alias}.")).Append(")");
+			}
+			if (string.IsNullOrEmpty(_orderby) && (_skip > 0 || _limit > 0)) {
+				sbnav.Append(" AND ROWNUM < ").Append(_skip + _limit + 1);
+			}
+			if (sbnav.Length > 0) {
+				sb.Append(" \r\nWHERE ").Append(sbnav.Remove(0, 5));
+			}
+			if (string.IsNullOrEmpty(_groupby) == false) {
+				sb.Append(_groupby);
+				if (string.IsNullOrEmpty(_having) == false)
+					sb.Append(" \r\nHAVING ").Append(_having.Substring(5));
+			}
+			sb.Append(_orderby);
+
+			if (string.IsNullOrEmpty(_orderby)) {
+				if (_skip > 0)
+					sb.Insert(0, "SELECT t.* FROM (").Append(") t WHERE t.\"__rownum__\" > ").Append(_skip);
+			} else {
+				if (_skip > 0 && _limit > 0) sb.Insert(0, "SELECT t.* FROM (SELECT rt.*, ROWNUM AS \"__rownum__\" FROM (").Append(") rt WHERE ROWNUM < ").Append(_skip + _limit + 1).Append(") t WHERE t.\"__rownum__\" > ").Append(_skip);
+				else if (_skip > 0) sb.Insert(0, "SELECT t.* FROM (").Append(") t WHERE ROWNUM > ").Append(_skip);
+				else if (_limit > 0) sb.Insert(0, "SELECT t.* FROM (").Append(") t WHERE ROWNUM < ").Append(_limit + 1);
+			}
+
+			sbnav.Clear();
+			return sb.ToString();
+		}
+
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override ISelect<T1, T2> From<T2>(Expression<Func<ISelectFromExpression<T1>, T2, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3> From<T2, T3>(Expression<Func<ISelectFromExpression<T1>, T2, T3, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4> From<T2, T3, T4>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5> From<T2, T3, T4, T5>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5, T6> From<T2, T3, T4, T5, T6>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5, T6, T7> From<T2, T3, T4, T5, T6, T7>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6, T7>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8> From<T2, T3, T4, T5, T6, T7, T8>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> From<T2, T3, T4, T5, T6, T7, T8, T9>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override ISelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> From<T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression<Func<ISelectFromExpression<T1>, T2, T3, T4, T5, T6, T7, T8, T9, T10, ISelectFromExpression<T1>>> exp) { this.InternalFrom(exp?.Body); var ret = new OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(_orm, _commonUtils, _commonExpression, null); OracleSelect<T1>.CopyData(this, ret, exp?.Parameters); return ret; }
+		public override string ToSql(string field = null) => ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2> : FreeSql.Internal.CommonProvider.Select2Provider<T1, T2> where T1 : class where T2 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3> : FreeSql.Internal.CommonProvider.Select3Provider<T1, T2, T3> where T1 : class where T2 : class where T3 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4> : FreeSql.Internal.CommonProvider.Select4Provider<T1, T2, T3, T4> where T1 : class where T2 : class where T3 : class where T4 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5> : FreeSql.Internal.CommonProvider.Select5Provider<T1, T2, T3, T4, T5> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5, T6> : FreeSql.Internal.CommonProvider.Select6Provider<T1, T2, T3, T4, T5, T6> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5, T6, T7> : FreeSql.Internal.CommonProvider.Select7Provider<T1, T2, T3, T4, T5, T6, T7> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8> : FreeSql.Internal.CommonProvider.Select8Provider<T1, T2, T3, T4, T5, T6, T7, T8> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9> : FreeSql.Internal.CommonProvider.Select9Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+	class OracleSelect<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : FreeSql.Internal.CommonProvider.Select10Provider<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> where T1 : class where T2 : class where T3 : class where T4 : class where T5 : class where T6 : class where T7 : class where T8 : class where T9 : class where T10 : class {
+		public OracleSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
+		public override string ToSql(string field = null) => OracleSelect<T1>.ToSqlStatic(_commonUtils, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, TableRuleInvoke, _orm);
+	}
+}

Providers/FreeSql.Provider.Oracle/Curd/OracleUpdate.cs

@@ -0,0 +1,61 @@
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FreeSql.Oracle.Curd {
+
+	class OracleUpdate<T1> : Internal.CommonProvider.UpdateProvider<T1> where T1 : class {
+
+		public OracleUpdate(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere)
+			: base(orm, commonUtils, commonExpression, dywhere) {
+		}
+
+		public override int ExecuteAffrows() => base.SplitExecuteAffrows(200, 999);
+		public override Task<int> ExecuteAffrowsAsync() => base.SplitExecuteAffrowsAsync(200, 999);
+		public override List<T1> ExecuteUpdated() => base.SplitExecuteUpdated(200, 999);
+		public override Task<List<T1>> ExecuteUpdatedAsync() => base.SplitExecuteUpdatedAsync(200, 999);
+
+
+		protected override List<T1> RawExecuteUpdated() {
+			throw new NotImplementedException();
+		}
+		protected override Task<List<T1>> RawExecuteUpdatedAsync() {
+			throw new NotImplementedException();
+		}
+
+		protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {
+			if (_table.Primarys.Length == 1) {
+				caseWhen.Append(_commonUtils.QuoteReadColumn(_table.Primarys.First().Attribute.MapType, _commonUtils.QuoteSqlName(_table.Primarys.First().Attribute.Name)));
+				return;
+			}
+			caseWhen.Append("(");
+			var pkidx = 0;
+			foreach (var pk in _table.Primarys) {
+				if (pkidx > 0) caseWhen.Append(" || ");
+				caseWhen.Append(_commonUtils.QuoteReadColumn(pk.Attribute.MapType, _commonUtils.QuoteSqlName(pk.Attribute.Name)));
+				++pkidx;
+			}
+			caseWhen.Append(")");
+		}
+
+		protected override void ToSqlWhen(StringBuilder sb, ColumnInfo[] primarys, object d) {
+			if (_table.Primarys.Length == 1) {
+				sb.Append(_commonUtils.FormatSql("{0}", _table.Primarys.First().GetMapValue(d)));
+				return;
+			}
+			sb.Append("(");
+			var pkidx = 0;
+			foreach (var pk in _table.Primarys) {
+				if (pkidx > 0) sb.Append(" || ");
+				sb.Append(_commonUtils.FormatSql("{0}", pk.GetMapValue(d)));
+				++pkidx;
+			}
+			sb.Append(")");
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/FreeSql.Provider.Oracle.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>netstandard2.0</TargetFramework>
+		<Version>0.6.1</Version>
+		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+		<Authors>YeXiangQin</Authors>
+		<Description>FreeSql 数据库实现，基于 Oracle 11</Description>
+		<PackageProjectUrl>https://github.com/2881099/FreeSql</PackageProjectUrl>
+		<RepositoryUrl>https://github.com/2881099/FreeSql</RepositoryUrl>
+		<RepositoryType>git</RepositoryType>
+		<PackageLicenseExpression>MIT</PackageLicenseExpression>
+		<PackageTags>FreeSql;ORM</PackageTags>
+		<PackageId>$(AssemblyName)</PackageId>
+		<Title>$(AssemblyName)</Title>
+		<IsPackable>true</IsPackable>
+		<GenerateAssemblyInfo>true</GenerateAssemblyInfo>
+	</PropertyGroup>
+	
+	<ItemGroup>
+		<PackageReference Include="Oracle.ManagedDataAccess.Core" Version="2.18.5" />
+	</ItemGroup>
+	
+	<ItemGroup>
+	  <ProjectReference Include="..\..\FreeSql\FreeSql.csproj" />
+	</ItemGroup>
+	
+</Project>
+	

Providers/FreeSql.Provider.Oracle/OracleAdo/OracleAdo.cs

@@ -0,0 +1,61 @@
+using FreeSql.Internal;
+using Oracle.ManagedDataAccess.Client;
+using SafeObjectPool;
+using System;
+using System.Collections;
+using System.Data.Common;
+using System.Text;
+using System.Threading;
+
+namespace FreeSql.Oracle {
+	class OracleAdo : FreeSql.Internal.CommonProvider.AdoProvider {
+		public OracleAdo() : base(DataType.Oracle) { }
+		public OracleAdo(CommonUtils util, string masterConnectionString, string[] slaveConnectionStrings) : base(DataType.Oracle) {
+			base._util = util;
+			if (!string.IsNullOrEmpty(masterConnectionString))
+				MasterPool = new OracleConnectionPool("主库", masterConnectionString, null, null);
+			if (slaveConnectionStrings != null) {
+				foreach (var slaveConnectionString in slaveConnectionStrings) {
+					var slavePool = new OracleConnectionPool($"从库{SlavePools.Count + 1}", slaveConnectionString, () => Interlocked.Decrement(ref slaveUnavailables), () => Interlocked.Increment(ref slaveUnavailables));
+					SlavePools.Add(slavePool);
+				}
+			}
+		}
+		static DateTime dt1970 = new DateTime(1970, 1, 1);
+		public override object AddslashesProcessParam(object param, Type mapType) {
+			if (param == null) return "NULL";
+			if (mapType != null && mapType != param.GetType())
+				param = Utils.GetDataReaderValue(mapType, param);
+			if (param is bool || param is bool?)
+				return (bool)param ? 1 : 0;
+			else if (param is string || param is char)
+				return string.Concat("'", param.ToString().Replace("'", "''"), "'");
+			else if (param is Enum)
+				return ((Enum)param).ToInt64();
+			else if (decimal.TryParse(string.Concat(param), out var trydec))
+				return param;
+			else if (param is DateTime || param is DateTime?)
+				return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+			else if (param is TimeSpan || param is TimeSpan?)
+				return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
+			else if (param is IEnumerable) {
+				var sb = new StringBuilder();
+				var ie = param as IEnumerable;
+				foreach (var z in ie) sb.Append(",").Append(AddslashesProcessParam(z, mapType));
+				return sb.Length == 0 ? "(NULL)" : sb.Remove(0, 1).Insert(0, "(").Append(")").ToString();
+			}
+			return string.Concat("'", param.ToString().Replace("'", "''"), "'");
+			//if (param is string) return string.Concat('N', nparms[a]);
+		}
+
+		protected override DbCommand CreateCommand() {
+			return new OracleCommand();
+		}
+
+		protected override void ReturnConnection(ObjectPool<DbConnection> pool, Object<DbConnection> conn, Exception ex) {
+			(pool as OracleConnectionPool).Return(conn, ex);
+		}
+
+		protected override DbParameter[] GetDbParamtersByObject(string sql, object obj) => _util.GetDbParamtersByObject(sql, obj);
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleAdo/OracleConnectionPool.cs

@@ -0,0 +1,191 @@
+using Oracle.ManagedDataAccess.Client;
+using SafeObjectPool;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace FreeSql.Oracle {
+
+	class OracleConnectionPool : ObjectPool<DbConnection> {
+
+		internal Action availableHandler;
+		internal Action unavailableHandler;
+		internal string UserId { get; set; }
+
+		public OracleConnectionPool(string name, string connectionString, Action availableHandler, Action unavailableHandler) : base(null) {
+			var userIdMatch = Regex.Match(connectionString, @"User\s+Id\s*=\s*([^;]+)", RegexOptions.IgnoreCase);
+			if (userIdMatch.Success == false) throw new Exception(@"从 ConnectionString 中无法匹配 User\s+Id\s+=([^;]+)");
+			this.UserId = userIdMatch.Groups[1].Value.Trim().ToUpper();
+
+			var policy = new OracleConnectionPoolPolicy {
+				_pool = this,
+				Name = name
+			};
+			this.Policy = policy;
+			policy.ConnectionString = connectionString;
+
+			this.availableHandler = availableHandler;
+			this.unavailableHandler = unavailableHandler;
+		}
+
+		public void Return(Object<DbConnection> obj, Exception exception, bool isRecreate = false) {
+			if (exception != null && exception is OracleException) {
+
+				if (exception is System.IO.IOException) {
+
+					base.SetUnavailable(exception);
+
+				} else if (obj.Value.Ping() == false) {
+
+					base.SetUnavailable(exception);
+				}
+			}
+			base.Return(obj, isRecreate);
+		}
+	}
+
+	class OracleConnectionPoolPolicy : IPolicy<DbConnection> {
+
+		internal OracleConnectionPool _pool;
+		public string Name { get; set; } = "Oracle Connection 对象池";
+		public int PoolSize { get; set; } = 100;
+		public TimeSpan SyncGetTimeout { get; set; } = TimeSpan.FromSeconds(10);
+		public TimeSpan IdleTimeout { get; set; } = TimeSpan.Zero;
+		public int AsyncGetCapacity { get; set; } = 10000;
+		public bool IsThrowGetTimeoutException { get; set; } = true;
+		public int CheckAvailableInterval { get; set; } = 5;
+
+		static ConcurrentDictionary<string, int> dicConnStrIncr = new ConcurrentDictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
+		private string _connectionString;
+		public string ConnectionString {
+			get => _connectionString;
+			set {
+				_connectionString = value ?? "";
+
+				var pattern = @"Max\s*pool\s*size\s*=\s*(\d+)";
+				Match m = Regex.Match(_connectionString, pattern, RegexOptions.IgnoreCase);
+				if (m.Success == false || int.TryParse(m.Groups[1].Value, out var poolsize) == false || poolsize <= 0) poolsize = 100;
+				var connStrIncr = dicConnStrIncr.AddOrUpdate(_connectionString, 1, (oldkey, oldval) => oldval + 1);
+				PoolSize = poolsize + connStrIncr;
+				_connectionString = m.Success ?
+					Regex.Replace(_connectionString, pattern, $"Max pool size={PoolSize}", RegexOptions.IgnoreCase) :
+					$"{_connectionString};Max pool size={PoolSize}";
+
+				pattern = @"Connection\s*LifeTime\s*=\s*(\d+)";
+				m = Regex.Match(_connectionString, pattern, RegexOptions.IgnoreCase);
+				if (m.Success) {
+					IdleTimeout = TimeSpan.FromSeconds(int.Parse(m.Groups[1].Value));
+					_connectionString = Regex.Replace(_connectionString, pattern, "", RegexOptions.IgnoreCase);
+				}
+
+				var minPoolSize = 0;
+				pattern = @"Min\s*pool\s*size\s*=\s*(\d+)";
+				m = Regex.Match(_connectionString, pattern, RegexOptions.IgnoreCase);
+				if (m.Success) {
+					minPoolSize = int.Parse(m.Groups[1].Value);
+					_connectionString = Regex.Replace(_connectionString, pattern, "", RegexOptions.IgnoreCase);
+				}
+
+				FreeSql.Internal.CommonUtils.PrevReheatConnectionPool(_pool, minPoolSize);
+			}
+		}
+
+		public bool OnCheckAvailable(Object<DbConnection> obj) {
+			if (obj.Value.State == ConnectionState.Closed) obj.Value.Open();
+			return obj.Value.Ping(true);
+		}
+
+		public DbConnection OnCreate() {
+			var conn = new OracleConnection(_connectionString);
+			return conn;
+		}
+
+		public void OnDestroy(DbConnection obj) {
+			if (obj.State != ConnectionState.Closed) obj.Close();
+			obj.Dispose();
+		}
+
+		public void OnGet(Object<DbConnection> obj) {
+
+			if (_pool.IsAvailable) {
+
+				if (obj.Value.State != ConnectionState.Open || DateTime.Now.Subtract(obj.LastReturnTime).TotalSeconds > 60 && obj.Value.Ping() == false) {
+
+					try {
+						obj.Value.Open();
+					} catch (Exception ex) {
+						if (_pool.SetUnavailable(ex) == true)
+							throw new Exception($"【{this.Name}】状态不可用，等待后台检查程序恢复方可使用。{ex.Message}");
+					}
+				}
+			}
+		}
+
+		async public Task OnGetAsync(Object<DbConnection> obj) {
+
+			if (_pool.IsAvailable) {
+
+				if (obj.Value.State != ConnectionState.Open || DateTime.Now.Subtract(obj.LastReturnTime).TotalSeconds > 60 && (await obj.Value.PingAsync()) == false) {
+
+					try {
+						await obj.Value.OpenAsync();
+					} catch (Exception ex) {
+						if (_pool.SetUnavailable(ex) == true)
+							throw new Exception($"【{this.Name}】状态不可用，等待后台检查程序恢复方可使用。{ex.Message}");
+					}
+				}
+			}
+		}
+
+		public void OnGetTimeout() {
+
+		}
+
+		public void OnReturn(Object<DbConnection> obj) {
+
+		}
+
+		public void OnAvailable() {
+			_pool.availableHandler?.Invoke();
+		}
+
+		public void OnUnavailable() {
+			_pool.unavailableHandler?.Invoke();
+		}
+	}
+
+	static class DbConnectionExtensions {
+
+		static DbCommand PingCommand(DbConnection conn) {
+			var cmd = conn.CreateCommand();
+			cmd.CommandTimeout = 5;
+			cmd.CommandText = "select 1 from dual";
+			return cmd;
+		}
+		public static bool Ping(this DbConnection that, bool isThrow = false) {
+			try {
+				PingCommand(that).ExecuteNonQuery();
+				return true;
+			} catch {
+				if (that.State != ConnectionState.Closed) try { that.Close(); } catch { }
+				if (isThrow) throw;
+				return false;
+			}
+		}
+		async public static Task<bool> PingAsync(this DbConnection that, bool isThrow = false) {
+			try {
+				await PingCommand(that).ExecuteNonQueryAsync();
+				return true;
+			} catch {
+				if (that.State != ConnectionState.Closed) try { that.Close(); } catch { }
+				if (isThrow) throw;
+				return false;
+			}
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleCodeFirst.cs

@@ -0,0 +1,372 @@
+using FreeSql.DataAnnotations;
+using FreeSql.DatabaseModel;
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using Oracle.ManagedDataAccess.Client;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace FreeSql.Oracle {
+
+	class OracleCodeFirst : ICodeFirst {
+		IFreeSql _orm;
+		protected CommonUtils _commonUtils;
+		protected CommonExpression _commonExpression;
+		public OracleCodeFirst(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
+			_orm = orm;
+			_commonUtils = commonUtils;
+			_commonExpression = commonExpression;
+		}
+
+		public bool IsAutoSyncStructure { get; set; } = false;
+		public bool IsSyncStructureToLower { get; set; } = false;
+		public bool IsSyncStructureToUpper { get; set; } = false;
+		public bool IsConfigEntityFromDbFirst { get; set; } = false;
+		public bool IsNoneCommandParameter { get; set; } = false;
+		public bool IsLazyLoading { get; set; } = false;
+
+		static object _dicCsToDbLock = new object();
+		static Dictionary<string, (OracleDbType type, string dbtype, string dbtypeFull, bool? isUnsigned, bool? isnullable, object defaultValue)> _dicCsToDb = new Dictionary<string, (OracleDbType type, string dbtype, string dbtypeFull, bool? isUnsigned, bool? isnullable, object defaultValue)>() {
+				{ typeof(bool).FullName,  (OracleDbType.Boolean, "number","number(1) NOT NULL", null, false, false) },{ typeof(bool?).FullName,  (OracleDbType.Boolean, "number","number(1) NULL", null, true, null) },
+
+				{ typeof(sbyte).FullName,  (OracleDbType.Decimal, "number", "number(4) NOT NULL", false, false, 0) },{ typeof(sbyte?).FullName,  (OracleDbType.Decimal, "number", "number(4) NULL", false, true, null) },
+				{ typeof(short).FullName,  (OracleDbType.Int16, "number","number(6) NOT NULL", false, false, 0) },{ typeof(short?).FullName,  (OracleDbType.Int16, "number", "number(6) NULL", false, true, null) },
+				{ typeof(int).FullName,  (OracleDbType.Int32, "number", "number(11) NOT NULL", false, false, 0) },{ typeof(int?).FullName,  (OracleDbType.Int32, "number", "number(11) NULL", false, true, null) },
+				{ typeof(long).FullName,  (OracleDbType.Int64, "number","number(21) NOT NULL", false, false, 0) },{ typeof(long?).FullName,  (OracleDbType.Int64, "number","number(21) NULL", false, true, null) },
+
+				{ typeof(byte).FullName,  (OracleDbType.Byte, "number","number(3) NOT NULL", true, false, 0) },{ typeof(byte?).FullName,  (OracleDbType.Byte, "number","number(3) NULL", true, true, null) },
+				{ typeof(ushort).FullName,  (OracleDbType.Decimal, "number","number(5) NOT NULL", true, false, 0) },{ typeof(ushort?).FullName,  (OracleDbType.Decimal, "number", "number(5) NULL", true, true, null) },
+				{ typeof(uint).FullName,  (OracleDbType.Decimal, "number", "number(10) NOT NULL", true, false, 0) },{ typeof(uint?).FullName,  (OracleDbType.Decimal, "number", "number(10) NULL", true, true, null) },
+				{ typeof(ulong).FullName,  (OracleDbType.Decimal, "number", "number(20) NOT NULL", true, false, 0) },{ typeof(ulong?).FullName,  (OracleDbType.Decimal, "number", "number(20) NULL", true, true, null) },
+
+				{ typeof(double).FullName,  (OracleDbType.Double, "float", "float(126) NOT NULL", false, false, 0) },{ typeof(double?).FullName,  (OracleDbType.Double, "float", "float(126) NULL", false, true, null) },
+				{ typeof(float).FullName,  (OracleDbType.Single, "float","float(63) NOT NULL", false, false, 0) },{ typeof(float?).FullName,  (OracleDbType.Single, "float","float(63) NULL", false, true, null) },
+				{ typeof(decimal).FullName,  (OracleDbType.Decimal, "number", "number(10,2) NOT NULL", false, false, 0) },{ typeof(decimal?).FullName,  (OracleDbType.Decimal, "number", "number(10,2) NULL", false, true, null) },
+
+				{ typeof(TimeSpan).FullName,  (OracleDbType.IntervalDS, "interval day to second","interval day(2) to second(6) NOT NULL", false, false, 0) },{ typeof(TimeSpan?).FullName,  (OracleDbType.IntervalDS, "interval day to second", "interval day(2) to second(6) NULL",false, true, null) },
+				{ typeof(DateTime).FullName,  (OracleDbType.TimeStamp, "timestamp", "timestamp(6) NOT NULL", false, false, new DateTime(1970,1,1)) },{ typeof(DateTime?).FullName,  (OracleDbType.TimeStamp, "timestamp", "timestamp(6) NULL", false, true, null) },
+				{ typeof(DateTimeOffset).FullName,  (OracleDbType.TimeStampLTZ, "timestamp with local time zone", "timestamp(6) with local time zone NOT NULL", false, false, new DateTime(1970,1,1)) },{ typeof(DateTimeOffset?).FullName,  (OracleDbType.TimeStampLTZ, "timestamp with local time zone", "timestamp(6) with local time zone NULL", false, true, null) },
+
+				{ typeof(byte[]).FullName,  (OracleDbType.Blob, "blob", "blob NULL", false, null, new byte[0]) },
+				{ typeof(string).FullName,  (OracleDbType.NVarchar2, "nvarchar2", "nvarchar2(255) NULL", false, null, "") },
+
+				{ typeof(Guid).FullName,  (OracleDbType.Char, "char", "char(36 CHAR) NOT NULL", false, false, Guid.Empty) },{ typeof(Guid?).FullName,  (OracleDbType.Char, "char", "char(36 CHAR) NULL", false, true, null) },
+			};
+
+		public (int type, string dbtype, string dbtypeFull, bool? isnullable, object defaultValue)? GetDbInfo(Type type) {
+			if (_dicCsToDb.TryGetValue(type.FullName, out var trydc)) return new (int, string, string, bool?, object)?(((int)trydc.type, trydc.dbtype, trydc.dbtypeFull, trydc.isnullable, trydc.defaultValue));
+			if (type.IsArray) return null;
+			var enumType = type.IsEnum ? type : null;
+			if (enumType == null && type.IsNullableType() && type.GenericTypeArguments.Length == 1 && type.GenericTypeArguments.First().IsEnum) enumType = type.GenericTypeArguments.First();
+			if (enumType != null) {
+				var newItem = enumType.GetCustomAttributes(typeof(FlagsAttribute), false).Any() ?
+					(OracleDbType.Int32, "number", $"number(16){(type.IsEnum ? " NOT NULL" : "")}", false, type.IsEnum ? false : true, Enum.GetValues(enumType).GetValue(0)) :
+					(OracleDbType.Int64, "number", $"number(32){(type.IsEnum ? " NOT NULL" : "")}", false, type.IsEnum ? false : true, Enum.GetValues(enumType).GetValue(0));
+				if (_dicCsToDb.ContainsKey(type.FullName) == false) {
+					lock (_dicCsToDbLock) {
+						if (_dicCsToDb.ContainsKey(type.FullName) == false)
+							_dicCsToDb.Add(type.FullName, newItem);
+					}
+				}
+				return ((int)newItem.Item1, newItem.Item2, newItem.Item3, newItem.Item5, newItem.Item6);
+			}
+			return null;
+		}
+
+		public string GetComparisonDDLStatements<TEntity>() => this.GetComparisonDDLStatements(typeof(TEntity));
+		public string GetComparisonDDLStatements(params Type[] entityTypes) {
+			var userId = (_orm.Ado.MasterPool as OracleConnectionPool).UserId;
+			var seqcols = new List<(ColumnInfo, string[], bool)>(); //序列
+
+			var sb = new StringBuilder();
+			var sbDeclare = new StringBuilder();
+			foreach (var entityType in entityTypes) {
+				if (sb.Length > 0) sb.Append("\r\n");
+				var tb = _commonUtils.GetTableByEntity(entityType);
+				if (tb == null) throw new Exception($"类型 {entityType.FullName} 不可迁移");
+				if (tb.Columns.Any() == false) throw new Exception($"类型 {entityType.FullName} 不可迁移，可迁移属性0个");
+				var tbname = tb.DbName.Split(new[] { '.' }, 2);
+				if (tbname?.Length == 1) tbname = new[] { userId, tbname[0] };
+
+				var tboldname = tb.DbOldName?.Split(new[] { '.' }, 2); //旧表名
+				if (tboldname?.Length == 1) tboldname = new[] { userId, tboldname[0] };
+
+				if (string.Compare(tbname[0], userId) != 0 && _orm.Ado.ExecuteScalar(CommandType.Text, _commonUtils.FormatSql(" select 1 from sys.dba_users where username={0}", tbname[0])) == null) //创建数据库
+					throw new NotImplementedException($"Oracle CodeFirst 不支持代码创建 tablespace 与 schemas {tbname[0]}");
+
+				var sbalter = new StringBuilder();
+				var istmpatler = false; //创建临时表，导入数据，删除旧表，修改
+				if (_orm.Ado.ExecuteScalar(CommandType.Text, _commonUtils.FormatSql(" select 1 from all_tab_comments where owner={0} and table_name={1}", tbname)) == null) { //表不存在
+					if (tboldname != null) {
+						if (_orm.Ado.ExecuteScalar(CommandType.Text, _commonUtils.FormatSql(" select 1 from all_tab_comments where owner={0} and table_name={1}", tboldname)) == null)
+							//模式或表不存在
+							tboldname = null;
+					}
+					if (tboldname == null) {
+						//创建表
+						sb.Append("execute immediate 'CREATE TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" ( ");
+						foreach (var tbcol in tb.Columns.Values) {
+							sb.Append(" \r\n  ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(" ").Append(tbcol.Attribute.DbType).Append(",");
+							if (tbcol.Attribute.IsIdentity == true) seqcols.Add((tbcol, tbname, true));
+						}
+						if (tb.Primarys.Any()) {
+							sb.Append(" \r\n  CONSTRAINT ").Append(tbname[0]).Append("_").Append(tbname[1]).Append("_pk1 PRIMARY KEY (");
+							foreach (var tbcol in tb.Primarys) sb.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+							sb.Remove(sb.Length - 2, 2).Append("),");
+						}
+						foreach (var uk in tb.Uniques) {
+							sb.Append(" \r\n  CONSTRAINT ").Append(_commonUtils.QuoteSqlName(uk.Key)).Append(" UNIQUE (");
+							foreach (var tbcol in uk.Value) sb.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+							sb.Remove(sb.Length - 2, 2).Append("),");
+						}
+						sb.Remove(sb.Length - 1, 1);
+						sb.Append("\r\n) \r\nLOGGING \r\nNOCOMPRESS \r\nNOCACHE\r\n';\r\n");
+						continue;
+					}
+					//如果新表，旧表在一个模式下，直接修改表名
+					if (string.Compare(tbname[0], tboldname[0], true) == 0)
+						sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tboldname[0]}.{tboldname[1]}")).Append(" RENAME TO ").Append(_commonUtils.QuoteSqlName($"{tbname[1]}")).Append("';\r\n");
+					else {
+						//如果新表，旧表不在一起，创建新表，导入数据，删除旧表
+						istmpatler = true;
+					}
+				} else
+					tboldname = null; //如果新表已经存在，不走改表名逻辑
+
+				//对比字段，只可以修改类型、增加字段、有限的修改字段名；保证安全不删除字段
+				var sql = _commonUtils.FormatSql($@"
+select 
+column_name,
+data_type,
+data_length,
+data_precision,
+data_scale,
+char_used,
+case when nullable = 'Y' then 1 else 0 end,
+nvl((select 1 from user_sequences where sequence_name='{Utils.GetCsName((tboldname ?? tbname).Last())}_seq_'||all_tab_columns.column_name), 0),
+nvl((select 1 from user_triggers where trigger_name='{Utils.GetCsName((tboldname ?? tbname).Last())}_seq_'||all_tab_columns.column_name||'TI'), 0)
+from all_tab_columns
+where owner={{0}} and table_name={{1}}", tboldname ?? tbname);
+				var ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+				var tbstruct = ds.ToDictionary(a => string.Concat(a[0]), a => {
+					var sqlType = GetOracleSqlTypeFullName(a);
+					return new {
+						column = string.Concat(a[0]),
+						sqlType,
+						is_nullable = string.Concat(a[6]) == "1",
+						is_identity = string.Concat(a[7]) == "1" && string.Concat(a[8]) == "1"
+					};
+				}, StringComparer.CurrentCultureIgnoreCase);
+
+				if (istmpatler == false) {
+					foreach (var tbcol in tb.Columns.Values) {
+						var dbtypeNoneNotNull = Regex.Replace(tbcol.Attribute.DbType, @"NOT\s+NULL", "NULL");
+						if (tbstruct.TryGetValue(tbcol.Attribute.Name, out var tbstructcol) ||
+						string.IsNullOrEmpty(tbcol.Attribute.OldName) == false && tbstruct.TryGetValue(tbcol.Attribute.OldName, out tbstructcol)) {
+							if (tbcol.Attribute.DbType.StartsWith(tbstructcol.sqlType, StringComparison.CurrentCultureIgnoreCase) == false)
+								istmpatler = true;
+								//sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" MODIFY (").Append(_commonUtils.QuoteSqlName(tbstructcol.column)).Append(" ").Append(dbtypeNoneNotNull).Append(")';\r\n");
+							if (tbcol.Attribute.IsNullable != tbstructcol.is_nullable) {
+								if (tbcol.Attribute.IsNullable == false)
+									sbalter.Append("execute immediate 'UPDATE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" SET ").Append(_commonUtils.QuoteSqlName(tbstructcol.column)).Append(" = ").Append(_commonUtils.FormatSql("{0}", tbcol.Attribute.DbDefautValue).Replace("'", "''")).Append(" WHERE ").Append(_commonUtils.QuoteSqlName(tbstructcol.column)).Append(" IS NULL';\r\n");
+								sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" MODIFY ").Append(_commonUtils.QuoteSqlName(tbstructcol.column)).Append(" ").Append(tbcol.Attribute.IsNullable == true ? "" : "NOT").Append(" NULL';\r\n");
+							}
+							if (tbcol.Attribute.IsIdentity != tbstructcol.is_identity)
+								seqcols.Add((tbcol, tbname, tbcol.Attribute.IsIdentity == true));
+							if (tbstructcol.column == tbcol.Attribute.OldName)
+								//修改列名
+								sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" RENAME ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.OldName)).Append(" TO ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append("';\r\n");
+							continue;
+						}
+						//添加列
+						sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" ADD (").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(" ").Append(dbtypeNoneNotNull).Append(")';\r\n");
+						if (tbcol.Attribute.IsNullable == false) {
+							sbalter.Append("execute immediate 'UPDATE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" SET ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(" = ").Append(_commonUtils.FormatSql("{0}", tbcol.Attribute.DbDefautValue).Replace("'", "''")).Append("';\r\n");
+							sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" MODIFY ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(" NOT NULL';\r\n");
+						}
+						if (tbcol.Attribute.IsIdentity == true) seqcols.Add((tbcol, tbname, tbcol.Attribute.IsIdentity == true));
+					}
+					var dsuksql = _commonUtils.FormatSql(@"
+select
+c.column_name,
+c.constraint_name
+from
+all_constraints a,
+all_cons_columns c
+where
+a.constraint_name = c.constraint_name
+and a.owner = c.owner
+and a.table_name = c.table_name
+and a.constraint_type in ('U')
+and a.owner in ({0}) and a.table_name in ({1})", tboldname ?? tbname);
+					var dsuk = _orm.Ado.ExecuteArray(CommandType.Text, dsuksql).Select(a => new[] { string.Concat(a[0]), string.Concat(a[1]) });
+					foreach (var uk in tb.Uniques) {
+						if (string.IsNullOrEmpty(uk.Key) || uk.Value.Any() == false) continue;
+						var dsukfind1 = dsuk.Where(a => string.Compare(a[1], uk.Key, true) == 0).ToArray();
+						if (dsukfind1.Any() == false || dsukfind1.Length != uk.Value.Count || dsukfind1.Where(a => uk.Value.Where(b => string.Compare(b.Attribute.Name, a[0], true) == 0).Any()).Count() != uk.Value.Count) {
+							if (dsukfind1.Any()) sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" DROP CONSTRAINT ").Append(_commonUtils.QuoteSqlName(uk.Key)).Append("';\r\n");
+							sbalter.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" ADD CONSTRAINT ").Append(_commonUtils.QuoteSqlName(uk.Key)).Append(" UNIQUE(");
+							foreach (var tbcol in uk.Value) sbalter.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+							sbalter.Remove(sbalter.Length - 2, 2).Append(")';\r\n");
+						}
+					}
+				}
+				if (istmpatler == false) {
+					sb.Append(sbalter);
+					continue;
+				}
+				var oldpk = _orm.Ado.ExecuteScalar(CommandType.Text, _commonUtils.FormatSql(@"select constraint_name from user_constraints where owner={0} and table_name={1} and constraint_type='P'", tbname))?.ToString();
+				if (string.IsNullOrEmpty(oldpk) == false)
+					sb.Append("execute immediate 'ALTER TABLE ").Append(_commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}")).Append(" DROP CONSTRAINT ").Append(oldpk).Append("';\r\n");
+
+				//创建临时表，数据导进临时表，然后删除原表，将临时表改名为原表名
+				var tablename = tboldname == null ? _commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}") : _commonUtils.QuoteSqlName($"{tboldname[0]}.{tboldname[1]}");
+				var tmptablename = _commonUtils.QuoteSqlName($"{tbname[0]}.FTmp_{tbname[1]}");
+				//创建临时表
+				sb.Append("execute immediate 'CREATE TABLE ").Append(tmptablename).Append(" ( ");
+				foreach (var tbcol in tb.Columns.Values) {
+					sb.Append(" \r\n  ").Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(" ").Append(tbcol.Attribute.DbType).Append(",");
+					if (tbcol.Attribute.IsIdentity == true) seqcols.Add((tbcol, tbname, true));
+				}
+				if (tb.Primarys.Any()) {
+					sb.Append(" \r\n  CONSTRAINT ").Append(tbname[0]).Append("_").Append(tbname[1]).Append("_pk2 PRIMARY KEY (");
+					foreach (var tbcol in tb.Primarys) sb.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+					sb.Remove(sb.Length - 2, 2).Append("),");
+				}
+				foreach (var uk in tb.Uniques) {
+					sb.Append(" \r\n  CONSTRAINT ").Append(_commonUtils.QuoteSqlName(uk.Key)).Append(" UNIQUE (");
+					foreach (var tbcol in uk.Value) sb.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+					sb.Remove(sb.Length - 2, 2).Append("),");
+				}
+				sb.Remove(sb.Length - 1, 1);
+				sb.Append("\r\n) LOGGING \r\nNOCOMPRESS \r\nNOCACHE\r\n';\r\n");
+				sb.Append("execute immediate 'INSERT INTO ").Append(tmptablename).Append(" (");
+				foreach (var tbcol in tb.Columns.Values)
+					sb.Append(_commonUtils.QuoteSqlName(tbcol.Attribute.Name)).Append(", ");
+				sb.Remove(sb.Length - 2, 2).Append(")\r\nSELECT ");
+				foreach (var tbcol in tb.Columns.Values) {
+					var insertvalue = "NULL";
+					if (tbstruct.TryGetValue(tbcol.Attribute.Name, out var tbstructcol) ||
+						string.IsNullOrEmpty(tbcol.Attribute.OldName) == false && tbstruct.TryGetValue(tbcol.Attribute.OldName, out tbstructcol)) {
+						insertvalue = _commonUtils.QuoteSqlName(tbstructcol.column);
+						if (tbcol.Attribute.DbType.StartsWith(tbstructcol.sqlType, StringComparison.CurrentCultureIgnoreCase) == false) {
+							var dbtypeNoneNotNull = Regex.Replace(tbcol.Attribute.DbType, @"(NOT\s+)?NULL", "");
+							insertvalue = $"cast({insertvalue} as {dbtypeNoneNotNull})";
+						}
+						if (tbcol.Attribute.IsNullable != tbstructcol.is_nullable)
+							insertvalue = $"nvl({insertvalue},{_commonUtils.FormatSql("{0}", tbcol.Attribute.DbDefautValue)})";
+					} else if (tbcol.Attribute.IsNullable == false)
+						insertvalue = _commonUtils.FormatSql("{0}", tbcol.Attribute.DbDefautValue);
+					sb.Append(insertvalue.Replace("'", "''")).Append(", ");
+				}
+				sb.Remove(sb.Length - 2, 2).Append(" FROM ").Append(tablename).Append("';\r\n");
+				sb.Append("execute immediate 'DROP TABLE ").Append(tablename).Append("';\r\n");
+				sb.Append("execute immediate 'ALTER TABLE ").Append(tmptablename).Append(" RENAME TO ").Append(_commonUtils.QuoteSqlName($"{tbname[1]}")).Append("';\r\n");
+			}
+			Dictionary<string, bool> dicDeclare = new Dictionary<string, bool>();
+			foreach (var seqcol in seqcols) {
+				var tbname = seqcol.Item2;
+				var seqname = Utils.GetCsName($"{tbname[1]}_seq_{seqcol.Item1.Attribute.Name}");
+				var tiggerName = seqname + "TI";
+				var tbname2 = _commonUtils.QuoteSqlName($"{tbname[0]}.{tbname[1]}");
+				var colname2 = _commonUtils.QuoteSqlName(seqcol.Item1.Attribute.Name);
+				if (dicDeclare.ContainsKey(seqname) == false) {
+					sbDeclare.Append("\r\n").Append(seqname).Append("IS NUMBER; \r\n");
+					dicDeclare.Add(seqname, true);
+				}
+				sb.Append(seqname).Append("IS := 0; \r\n")
+					.Append(" select count(1) into ").Append(seqname).Append(_commonUtils.FormatSql("IS from user_sequences where sequence_name={0}; \r\n", seqname))
+					.Append("if ").Append(seqname).Append("IS > 0 then \r\n")
+					.Append("  execute immediate 'DROP SEQUENCE ").Append(_commonUtils.QuoteSqlName(seqname)).Append("';\r\n")
+					.Append("end if; \r\n");
+				if (seqcol.Item3) {
+					var startWith = _orm.Ado.ExecuteScalar(CommandType.Text, _commonUtils.FormatSql(" select 1 from all_tab_comments where owner={0} and table_name={1}", tbname)) == null ? 1 :
+						_orm.Ado.ExecuteScalar(CommandType.Text, $" select nvl(max({colname2})+1,1) from {tbname2}");
+					sb.Append("execute immediate 'CREATE SEQUENCE ").Append(_commonUtils.QuoteSqlName(seqname)).Append(" start with ").Append(startWith).Append("';\r\n");
+					sb.Append("execute immediate 'CREATE OR REPLACE TRIGGER ").Append(_commonUtils.QuoteSqlName(tiggerName))
+						.Append(" \r\nbefore insert on ").Append(tbname2)
+						.Append(" \r\nfor each row \r\nbegin\r\nselect ").Append(_commonUtils.QuoteSqlName(seqname))
+						.Append(".nextval into :new.").Append(colname2).Append(" from dual;\r\nend;';\r\n");
+				} else {
+					if (dicDeclare.ContainsKey(tiggerName) == false) {
+						sbDeclare.Append("\r\n").Append(tiggerName).Append("IS NUMBER; \r\n");
+						dicDeclare.Add(tiggerName, true);
+					}
+					sb.Append(tiggerName).Append("IS := 0; \r\n")
+					.Append(" select count(1) into ").Append(tiggerName).Append(_commonUtils.FormatSql("IS from user_triggers where trigger_name={0}; \r\n", tiggerName))
+					.Append("if ").Append(tiggerName).Append("IS > 0 then \r\n")
+					.Append("  execute immediate 'DROP TRIGGER ").Append(_commonUtils.QuoteSqlName(tiggerName)).Append("';\r\n")
+					.Append("end if; \r\n");
+				}
+			}
+			if (sbDeclare.Length > 0) sbDeclare.Insert(0, "declare ");
+			return sb.Length == 0 ? null : sb.Insert(0, "BEGIN \r\n").Insert(0, sbDeclare.ToString()).Append("END;").ToString();
+		}
+
+		internal static string GetOracleSqlTypeFullName(object[] row) {
+			var a = row;
+			var sqlType = string.Concat(a[1]).ToUpper();
+			var data_length = long.Parse(string.Concat(a[2]));
+			long.TryParse(string.Concat(a[3]), out var data_precision);
+			long.TryParse(string.Concat(a[4]), out var data_scale);
+			var char_used = string.Concat(a[5]);
+			if (Regex.IsMatch(sqlType, @"INTERVAL DAY\(\d+\) TO SECOND\(\d+\)", RegexOptions.IgnoreCase)) {
+			} else if (Regex.IsMatch(sqlType, @"INTERVAL YEAR\(\d+\) TO MONTH", RegexOptions.IgnoreCase)) {
+			} else if (sqlType.StartsWith("TIMESTAMP", StringComparison.CurrentCultureIgnoreCase)) {
+			} else if (sqlType.StartsWith("BLOB")) {
+			} else if (char_used.ToLower() == "c")
+				sqlType += sqlType.StartsWith("N") ? $"({data_length / 2})" : $"({data_length / 4} CHAR)";
+			else if (char_used.ToLower() == "b")
+				sqlType += $"({data_length} BYTE)";
+			else if (sqlType.ToLower() == "float")
+				sqlType += $"({data_precision})";
+			else if (data_precision > 0 && data_scale > 0)
+				sqlType += $"({data_precision},{data_scale})";
+			else if (data_precision > 0)
+				sqlType += $"({data_precision})";
+			else
+				sqlType += $"({data_length})";
+			return sqlType;
+		}
+
+		static object syncStructureLock = new object();
+		ConcurrentDictionary<string, bool> dicSyced = new ConcurrentDictionary<string, bool>();
+		public bool SyncStructure<TEntity>() => this.SyncStructure(typeof(TEntity));
+		public bool SyncStructure(params Type[] entityTypes) {
+			if (entityTypes == null) return true;
+			var syncTypes = entityTypes.Where(a => dicSyced.ContainsKey(a.FullName) == false).ToArray();
+			if (syncTypes.Any() == false) return true;
+			var before = new Aop.SyncStructureBeforeEventArgs(entityTypes);
+			_orm.Aop.SyncStructureBefore?.Invoke(this, before);
+			Exception exception = null;
+			string ddl = null;
+			try {
+				lock (syncStructureLock) {
+					ddl = this.GetComparisonDDLStatements(syncTypes);
+					if (string.IsNullOrEmpty(ddl)) {
+						foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
+						return true;
+					}
+					var affrows = _orm.Ado.ExecuteNonQuery(CommandType.Text, ddl);
+					foreach (var syncType in syncTypes) dicSyced.TryAdd(syncType.FullName, true);
+					return affrows > 0;
+				}
+			} catch (Exception ex) {
+				exception = ex;
+				throw ex;
+			} finally {
+				var after = new Aop.SyncStructureAfterEventArgs(before, ddl, exception);
+				_orm.Aop.SyncStructureAfter?.Invoke(this, after);
+			}
+		}
+		public ICodeFirst ConfigEntity<T>(Action<TableFluent<T>> entity) => _commonUtils.ConfigEntity(entity);
+		public ICodeFirst ConfigEntity(Type type, Action<TableFluent> entity) => _commonUtils.ConfigEntity(type, entity);
+		public TableAttribute GetConfigEntity(Type type) => _commonUtils.GetConfigEntity(type);
+		public TableInfo GetTableByEntity(Type type) => _commonUtils.GetTableByEntity(type);
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleDbFirst.cs

@@ -0,0 +1,427 @@
+using FreeSql.DatabaseModel;
+using FreeSql.Internal;
+using Oracle.ManagedDataAccess.Client;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace FreeSql.Oracle {
+	class OracleDbFirst : IDbFirst {
+		IFreeSql _orm;
+		protected CommonUtils _commonUtils;
+		protected CommonExpression _commonExpression;
+		public OracleDbFirst(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
+			_orm = orm;
+			_commonUtils = commonUtils;
+			_commonExpression = commonExpression;
+		}
+
+		public int GetDbType(DbColumnInfo column) => (int)GetSqlDbType(column);
+		OracleDbType GetSqlDbType(DbColumnInfo column) {
+			var dbfull = column.DbTypeTextFull.ToLower();
+			switch (dbfull) {
+				case "number(1)": return OracleDbType.Boolean;
+
+				case "number(4)": return OracleDbType.Decimal;
+				case "number(6)": return OracleDbType.Int16;
+				case "number(11)": return OracleDbType.Int32;
+				case "number(21)": return OracleDbType.Int64;
+
+				case "number(3)": return OracleDbType.Byte;
+				case "number(5)": return OracleDbType.Decimal;
+				case "number(10)": return OracleDbType.Decimal;
+				case "number(20)": return OracleDbType.Decimal;
+
+				case "float(126)": return OracleDbType.Double;
+				case "float(63)": return OracleDbType.Single;
+				case "number(10,2)": return OracleDbType.Decimal;
+
+				case "interval day(2) to second(6)": return OracleDbType.IntervalDS;
+				case "timestamp(6)": return OracleDbType.TimeStamp;
+				case "timestamp(6) with local time zone": return OracleDbType.TimeStampLTZ;
+
+				case "blob": return OracleDbType.Blob;
+				case "nvarchar2(255)": return OracleDbType.NVarchar2;
+
+				case "char(36 char)": return OracleDbType.Char;
+			}
+			switch (column.DbTypeText.ToLower()) {
+				case "number":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["number(10,2)"]);
+					return OracleDbType.Decimal;
+				case "float":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["float(126)"]);
+					return OracleDbType.Double;
+				case "interval day to second":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["interval day(2) to second(6)"]);
+					return OracleDbType.IntervalDS;
+				case "timestamp":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["timestamp(6)"]);
+					return OracleDbType.TimeStamp;
+				case "timestamp with local time zone":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["timestamp(6) with local time zone"]);
+					return OracleDbType.TimeStampLTZ;
+				case "blob":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["blob"]);
+					return OracleDbType.Blob;
+				case "nvarchar2":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["nvarchar2(255)"]);
+					return OracleDbType.NVarchar2;
+				case "varchar2":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["nvarchar2(255)"]);
+					return OracleDbType.Varchar2;
+				case "char":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["char(36 char)"]);
+					return OracleDbType.Char;
+				case "clob":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["nvarchar2(255)"]);
+					return OracleDbType.Clob;
+				case "nclob":
+					_dicDbToCs.TryAdd(dbfull, _dicDbToCs["nvarchar2(255)"]);
+					return OracleDbType.NClob;
+			}
+			throw new NotImplementedException($"未实现 {column.DbTypeTextFull} 类型映射");
+		}
+
+		static ConcurrentDictionary<string, (string csConvert, string csParse, string csStringify, string csType, Type csTypeInfo, Type csNullableTypeInfo, string csTypeValue, string dataReaderMethod)> _dicDbToCs = new ConcurrentDictionary<string, (string csConvert, string csParse, string csStringify, string csType, Type csTypeInfo, Type csNullableTypeInfo, string csTypeValue, string dataReaderMethod)>();
+		static OracleDbFirst() {
+			var defaultDbToCs = new Dictionary<string, (string csConvert, string csParse, string csStringify, string csType, Type csTypeInfo, Type csNullableTypeInfo, string csTypeValue, string dataReaderMethod)>() {
+				{ "number(1)", ("(bool?)", "{0} == \"1\"", "{0} == true ? \"1\" : \"0\"", "bool?", typeof(bool), typeof(bool?), "{0}.Value", "GetBoolean") },
+
+				{ "number(4)", ("(sbyte?)", "sbyte.Parse({0})", "{0}.ToString()", "sbyte?", typeof(sbyte), typeof(sbyte?), "{0}.Value", "GetInt16") },
+				{ "number(6)", ("(short?)", "short.Parse({0})", "{0}.ToString()", "short?", typeof(short), typeof(short?), "{0}.Value", "GetInt16") },
+				{ "number(11)", ("(int?)", "int.Parse({0})", "{0}.ToString()", "int?", typeof(int), typeof(int?), "{0}.Value", "GetInt32") },
+				{ "number(21)", ("(long?)", "long.Parse({0})", "{0}.ToString()", "long?", typeof(long), typeof(long?), "{0}.Value", "GetInt64") },
+
+				{ "number(3)", ("(byte?)", "byte.Parse({0})", "{0}.ToString()", "byte?", typeof(byte), typeof(byte?), "{0}.Value", "GetByte") },
+				{ "number(5)", ("(ushort?)", "ushort.Parse({0})", "{0}.ToString()", "ushort?", typeof(ushort), typeof(ushort?), "{0}.Value", "GetInt32") },
+				{ "number(10)", ("(uint?)", "uint.Parse({0})", "{0}.ToString()", "uint?", typeof(uint), typeof(uint?), "{0}.Value", "GetInt64") },
+				{ "number(20)", ("(ulong?)", "ulong.Parse({0})", "{0}.ToString()", "ulong?", typeof(ulong), typeof(ulong?), "{0}.Value", "GetDecimal") },
+
+				{ "float(126)", ("(double?)", "double.Parse({0})", "{0}.ToString()", "double?", typeof(double), typeof(double?), "{0}.Value", "GetDouble") },
+				{ "float(63)", ("(float?)", "float.Parse({0})", "{0}.ToString()", "float?", typeof(float), typeof(float?), "{0}.Value", "GetFloat") },
+				{ "number(10,2)", ("(decimal?)", "decimal.Parse({0})", "{0}.ToString()", "decimal?", typeof(decimal), typeof(decimal?), "{0}.Value", "GetDecimal") },
+
+				{ "interval day(2) to second(6)", ("(TimeSpan?)", "TimeSpan.Parse(double.Parse({0}))", "{0}.Ticks.ToString()", "TimeSpan?", typeof(TimeSpan), typeof(TimeSpan?), "{0}.Value", "GetValue") },
+				{ "timestamp(6)", ("(DateTime?)", "new DateTime(long.Parse({0}))", "{0}.Ticks.ToString()", "DateTime?", typeof(DateTime), typeof(DateTime?), "{0}.Value", "GetValue") },
+				{ "timestamp(6) with local time zone", ("(DateTime?)", "new DateTime(long.Parse({0}))", "{0}.Ticks.ToString()", "DateTime?", typeof(DateTime), typeof(DateTime?), "{0}.Value", "GetValue") },
+
+				{ "blob", ("(byte[])", "Convert.FromBase64String({0})", "Convert.ToBase64String({0})", "byte[]", typeof(byte[]), typeof(byte[]), "{0}", "GetValue") },
+
+				{ "nvarchar2(255)", ("", "{0}.Replace(StringifySplit, \"|\")", "{0}.Replace(\"|\", StringifySplit)", "string", typeof(string), typeof(string), "{0}", "GetString") },
+				{ "char(36 char)", ("(Guid?)", "Guid.Parse({0})", "{0}.ToString()", "Guid?", typeof(Guid), typeof(Guid?), "{0}.Value", "GetGuid") },
+			};
+			foreach (var kv in defaultDbToCs)
+				_dicDbToCs.TryAdd(kv.Key, kv.Value);
+		}
+		
+
+		public string GetCsConvert(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? (column.IsNullable ? trydc.csConvert : trydc.csConvert.Replace("?", "")) : null;
+		public string GetCsParse(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? trydc.csParse : null;
+		public string GetCsStringify(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? trydc.csStringify : null;
+		public string GetCsType(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? (column.IsNullable ? trydc.csType : trydc.csType.Replace("?", "")) : null;
+		public Type GetCsTypeInfo(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? trydc.csTypeInfo : null;
+		public string GetCsTypeValue(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? trydc.csTypeValue : null;
+		public string GetDataReaderMethod(DbColumnInfo column) => _dicDbToCs.TryGetValue(column.DbTypeTextFull, out var trydc) ? trydc.dataReaderMethod : null;
+
+		public List<string> GetDatabases() {
+			var sql = @" select username from all_users";
+			var ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+			return ds.Select(a => a.FirstOrDefault()?.ToString()).ToList();
+		}
+
+		public List<DbTableInfo> GetTablesByDatabase(params string[] database2) {
+			var loc1 = new List<DbTableInfo>();
+			var loc2 = new Dictionary<string, DbTableInfo>();
+			var loc3 = new Dictionary<string, Dictionary<string, DbColumnInfo>>();
+			var database = database2?.ToArray();
+
+			if (database == null || database.Any() == false) {
+				var userUsers = _orm.Ado.ExecuteScalar("select username from user_users")?.ToString();
+				if (string.IsNullOrEmpty(userUsers)) return loc1;
+				database = new[] { userUsers };
+			}
+			var databaseIn = string.Join(",", database.Select(a => _commonUtils.FormatSql("{0}", a)));
+			var sql = string.Format(@"
+select
+a.owner || '.' || a.table_name,
+a.owner,
+a.table_name,
+b.comments,
+'TABLE'
+from all_tables a
+left join all_tab_comments b on b.owner = a.owner and b.table_name = a.table_name and b.table_type = 'TABLE'
+where a.owner in ({0})", databaseIn);
+			var ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+			if (ds == null) return loc1;
+
+			var loc6 = new List<string>();
+			var loc66 = new List<string>();
+			foreach (var row in ds) {
+				var table_id = string.Concat(row[0]);
+				var schema = string.Concat(row[1]);
+				var table = string.Concat(row[2]);
+				var comment = string.Concat(row[3]);
+				var type = string.Concat(row[4]) == "VIEW" ? DbTableType.VIEW : DbTableType.TABLE;
+				if (database.Length == 1) {
+					table_id = table_id.Substring(table_id.IndexOf('.') + 1);
+					schema = "";
+				}
+				loc2.Add(table_id, new DbTableInfo { Id = table_id, Schema = schema, Name = table, Comment = comment, Type = type });
+				loc3.Add(table_id, new Dictionary<string, DbColumnInfo>());
+				switch (type) {
+					case DbTableType.TABLE:
+					case DbTableType.VIEW:
+						loc6.Add(table.Replace("'", "''"));
+						break;
+					case DbTableType.StoreProcedure:
+						loc66.Add(table.Replace("'", "''"));
+						break;
+				}
+			}
+			if (loc6.Count == 0) return loc1;
+			var loc8 = "'" + string.Join("','", loc6.ToArray()) + "'";
+			var loc88 = "'" + string.Join("','", loc66.ToArray()) + "'";
+
+			sql = string.Format(@"
+select
+a.owner || '.' || a.table_name,
+a.column_name,
+a.data_type,
+a.data_length,
+a.data_precision,
+a.data_scale,
+a.char_used,
+case when nullable = 'Y' then 1 else 0 end,
+nvl((select 1 from user_sequences where upper(sequence_name)=upper(a.table_name||'_seq_'||a.column_name)), 0),
+b.comments
+from all_tab_cols a
+left join all_col_comments b on b.owner = a.owner and b.table_name = a.table_name and b.column_name = a.column_name
+where a.owner in ({1}) and a.table_name in ({0})
+", loc8, databaseIn);
+			ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+			if (ds == null) return loc1;
+
+			var ds2 = new List<object[]>();
+			foreach (var row in ds) {
+				var ds2item = new object[8];
+				ds2item[0] = row[0];
+				ds2item[1] = row[1];
+				ds2item[2] = Regex.Replace(string.Concat(row[2]), @"\(\d+\)", "");
+				ds2item[4] = OracleCodeFirst.GetOracleSqlTypeFullName(new object[] { row[1], row[2], row[3], row[4], row[5], row[6] });
+				ds2item[5] = string.Concat(row[7]) == "1";
+				ds2item[6] = string.Concat(row[8]) == "1";
+				ds2item[7] = string.Concat(row[9]);
+				ds2.Add(ds2item);
+			}
+			foreach (var row in ds2) {
+				string table_id = string.Concat(row[0]);
+				string column = string.Concat(row[1]);
+				string type = string.Concat(row[2]);
+				//long max_length = long.Parse(string.Concat(row[3]));
+				string sqlType = string.Concat(row[4]);
+				var m_len = Regex.Match(sqlType, @"\w+\((\d+)");
+				int max_length = m_len.Success ? int.Parse(m_len.Groups[1].Value) : -1;
+				bool is_nullable = string.Concat(row[5]) == "1";
+				bool is_identity = string.Concat(row[6]) == "1";
+				string comment = string.Concat(row[7]);
+				if (max_length == 0) max_length = -1;
+				if (database.Length == 1) {
+					table_id = table_id.Substring(table_id.IndexOf('.') + 1);
+				}
+				loc3[table_id].Add(column, new DbColumnInfo {
+					Name = column,
+					MaxLength = max_length,
+					IsIdentity = is_identity,
+					IsNullable = is_nullable,
+					IsPrimary = false,
+					DbTypeText = type,
+					DbTypeTextFull = sqlType,
+					Table = loc2[table_id],
+					Coment = comment
+				});
+				loc3[table_id][column].DbType = this.GetDbType(loc3[table_id][column]);
+				loc3[table_id][column].CsType = this.GetCsTypeInfo(loc3[table_id][column]);
+			}
+
+			sql = string.Format(@"
+select
+a.owner || '.' || a.table_name,
+c.column_name,
+c.constraint_name,
+case when a.constraint_type = 'U' then 1 else 0 end,
+case when a.constraint_type = 'P' then 1 else 0 end,
+0,
+0
+from
+all_constraints a,
+all_cons_columns c
+where
+a.constraint_name = c.constraint_name
+and a.owner = c.owner
+and a.table_name = c.table_name
+and a.constraint_type  in ('P', 'U')
+and a.owner in ({1}) and a.table_name in ({0})
+", loc8, databaseIn);
+			ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+			if (ds == null) return loc1;
+
+			var indexColumns = new Dictionary<string, Dictionary<string, List<DbColumnInfo>>>();
+			var uniqueColumns = new Dictionary<string, Dictionary<string, List<DbColumnInfo>>>();
+			foreach (var row in ds) {
+				string table_id = string.Concat(row[0]);
+				string column = string.Concat(row[1]);
+				string index_id = string.Concat(row[2]);
+				bool is_unique = string.Concat(row[3]) == "1";
+				bool is_primary_key = string.Concat(row[4]) == "1";
+				bool is_clustered = string.Concat(row[5]) == "1";
+				int is_desc = int.Parse(string.Concat(row[6]));
+				if (database.Length == 1) {
+					table_id = table_id.Substring(table_id.IndexOf('.') + 1);
+				}
+				if (loc3.ContainsKey(table_id) == false || loc3[table_id].ContainsKey(column) == false) continue;
+				var loc9 = loc3[table_id][column];
+				if (loc9.IsPrimary == false && is_primary_key) loc9.IsPrimary = is_primary_key;
+
+				Dictionary<string, List<DbColumnInfo>> loc10 = null;
+				List<DbColumnInfo> loc11 = null;
+				if (!indexColumns.TryGetValue(table_id, out loc10))
+					indexColumns.Add(table_id, loc10 = new Dictionary<string, List<DbColumnInfo>>());
+				if (!loc10.TryGetValue(index_id, out loc11))
+					loc10.Add(index_id, loc11 = new List<DbColumnInfo>());
+				loc11.Add(loc9);
+				if (is_unique && !is_primary_key) {
+					if (!uniqueColumns.TryGetValue(table_id, out loc10))
+						uniqueColumns.Add(table_id, loc10 = new Dictionary<string, List<DbColumnInfo>>());
+					if (!loc10.TryGetValue(index_id, out loc11))
+						loc10.Add(index_id, loc11 = new List<DbColumnInfo>());
+					loc11.Add(loc9);
+				}
+			}
+			foreach (string table_id in indexColumns.Keys) {
+				foreach (var column in indexColumns[table_id])
+					loc2[table_id].IndexesDict.Add(column.Key, column.Value);
+			}
+			foreach (string table_id in uniqueColumns.Keys) {
+				foreach (var column in uniqueColumns[table_id]) {
+					column.Value.Sort((c1, c2) => c1.Name.CompareTo(c2.Name));
+					loc2[table_id].UniquesDict.Add(column.Key, column.Value);
+				}
+			}
+
+			sql = string.Format(@"
+select
+a.owner || '.' || a.table_name,
+c.column_name,
+c.constraint_name,
+b.owner || '.' || b.table_name,
+1,
+d.column_name
+
+-- a.owner 外键拥有者,
+-- a.table_name 外键表,
+-- c.column_name 外键列,
+-- b.owner 主键拥有者,
+-- b.table_name 主键表,
+-- d.column_name 主键列,
+-- c.constraint_name 外键名,
+-- d.constraint_name 主键名
+
+from
+all_constraints a,
+all_constraints b,
+all_cons_columns c, --外键表
+all_cons_columns d  --主键表
+where
+a.r_constraint_name = b.constraint_name 　　
+and a.constraint_type = 'R' 　　
+and b.constraint_type = 'P' 　　
+and a.r_owner = b.owner 　　
+and a.constraint_name = c.constraint_name 　　
+and b.constraint_name = d.constraint_name 　　
+and a.owner = c.owner 　　
+and a.table_name = c.table_name 　　
+and b.owner = d.owner 　　
+and b.table_name = d.table_name
+and a.owner in ({1}) and a.table_name in ({0})
+", loc8, databaseIn);
+			ds = _orm.Ado.ExecuteArray(CommandType.Text, sql);
+			if (ds == null) return loc1;
+
+			var fkColumns = new Dictionary<string, Dictionary<string, DbForeignInfo>>();
+			foreach (var row in ds) {
+				string table_id = string.Concat(row[0]);
+				string column = string.Concat(row[1]);
+				string fk_id = string.Concat(row[2]);
+				string ref_table_id = string.Concat(row[3]);
+				bool is_foreign_key = string.Concat(row[4]) == "1";
+				string referenced_column = string.Concat(row[5]);
+				if (database.Length == 1) {
+					table_id = table_id.Substring(table_id.IndexOf('.') + 1);
+					ref_table_id = ref_table_id.Substring(ref_table_id.IndexOf('.') + 1);
+				}
+				if (loc3.ContainsKey(table_id) == false || loc3[table_id].ContainsKey(column) == false) continue;
+				var loc9 = loc3[table_id][column];
+				if (loc2.ContainsKey(ref_table_id) == false) continue;
+				var loc10 = loc2[ref_table_id];
+				var loc11 = loc3[ref_table_id][referenced_column];
+
+				Dictionary<string, DbForeignInfo> loc12 = null;
+				DbForeignInfo loc13 = null;
+				if (!fkColumns.TryGetValue(table_id, out loc12))
+					fkColumns.Add(table_id, loc12 = new Dictionary<string, DbForeignInfo>());
+				if (!loc12.TryGetValue(fk_id, out loc13))
+					loc12.Add(fk_id, loc13 = new DbForeignInfo { Table = loc2[table_id], ReferencedTable = loc10 });
+				loc13.Columns.Add(loc9);
+				loc13.ReferencedColumns.Add(loc11);
+			}
+			foreach (var table_id in fkColumns.Keys)
+				foreach (var fk in fkColumns[table_id])
+					loc2[table_id].ForeignsDict.Add(fk.Key, fk.Value);
+
+			foreach (var table_id in loc3.Keys) {
+				foreach (var loc5 in loc3[table_id].Values) {
+					loc2[table_id].Columns.Add(loc5);
+					if (loc5.IsIdentity) loc2[table_id].Identitys.Add(loc5);
+					if (loc5.IsPrimary) loc2[table_id].Primarys.Add(loc5);
+				}
+			}
+			foreach (var loc4 in loc2.Values) {
+				if (loc4.Primarys.Count == 0 && loc4.UniquesDict.Count > 0) {
+					foreach (var loc5 in loc4.UniquesDict.First().Value) {
+						loc5.IsPrimary = true;
+						loc4.Primarys.Add(loc5);
+					}
+				}
+				loc4.Primarys.Sort((c1, c2) => c1.Name.CompareTo(c2.Name));
+				loc4.Columns.Sort((c1, c2) => {
+					int compare = c2.IsPrimary.CompareTo(c1.IsPrimary);
+					if (compare == 0) {
+						bool b1 = loc4.ForeignsDict.Values.Where(fk => fk.Columns.Where(c3 => c3.Name == c1.Name).Any()).Any();
+						bool b2 = loc4.ForeignsDict.Values.Where(fk => fk.Columns.Where(c3 => c3.Name == c2.Name).Any()).Any();
+						compare = b2.CompareTo(b1);
+					}
+					if (compare == 0) compare = c1.Name.CompareTo(c2.Name);
+					return compare;
+				});
+				loc1.Add(loc4);
+			}
+			loc1.Sort((t1, t2) => {
+				var ret = t1.Schema.CompareTo(t2.Schema);
+				if (ret == 0) ret = t1.Name.CompareTo(t2.Name);
+				return ret;
+			});
+
+			loc2.Clear();
+			loc3.Clear();
+			return loc1;
+		}
+
+		public List<DbEnumInfo> GetEnumsByDatabase(params string[] database) {
+			return new List<DbEnumInfo>();
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleExpression.cs

@@ -0,0 +1,399 @@
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace FreeSql.Oracle {
+	class OracleExpression : CommonExpression {
+
+		public OracleExpression(CommonUtils common) : base(common) { }
+
+		public override string ExpressionLambdaToSqlOther(Expression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			switch (exp.NodeType) {
+				case ExpressionType.Convert:
+					var operandExp = (exp as UnaryExpression)?.Operand;
+					var gentype = exp.Type.NullableTypeOrThis();
+					if (gentype != operandExp.Type.NullableTypeOrThis()) {
+						switch (exp.Type.NullableTypeOrThis().ToString()) {
+							//case "System.Boolean": return $"({getExp(operandExp)} not in ('0','false'))";
+							case "System.Byte": return $"cast({getExp(operandExp)} as number)";
+							case "System.Char": return $"substr(to_char({getExp(operandExp)}), 1, 1)";
+							case "System.DateTime": return $"to_timestamp({getExp(operandExp)},'YYYY-MM-DD HH24:MI:SS.FF6')";
+							case "System.Decimal": return $"cast({getExp(operandExp)} as number)";
+							case "System.Double": return $"cast({getExp(operandExp)} as number)";
+							case "System.Int16":
+							case "System.Int32":
+							case "System.Int64":
+							case "System.SByte": return $"cast({getExp(operandExp)} as number)";
+							case "System.Single": return $"cast({getExp(operandExp)} as number)";
+							case "System.String": return $"to_char({getExp(operandExp)})";
+							case "System.UInt16":
+							case "System.UInt32":
+							case "System.UInt64": return $"cast({getExp(operandExp)} as number)";
+							case "System.Guid": return $"substr(to_char({getExp(operandExp)}), 1, 36)";
+						}
+					}
+					break;
+				case ExpressionType.Call:
+					var callExp = exp as MethodCallExpression;
+
+					switch (callExp.Method.Name) {
+						case "Parse":
+						case "TryParse":
+							switch (callExp.Method.DeclaringType.NullableTypeOrThis().ToString()) {
+								//case "System.Boolean": return $"({getExp(callExp.Arguments[0])} not in ('0','false'))";
+								case "System.Byte": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.Char": return $"substr(to_char({getExp(callExp.Arguments[0])}), 1, 1)";
+								case "System.DateTime": return $"to_timestamp({getExp(callExp.Arguments[0])},'YYYY-MM-DD HH24:MI:SS.FF6')";
+								case "System.Decimal": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.Double": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.Int16":
+								case "System.Int32":
+								case "System.Int64":
+								case "System.SByte": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.Single": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.UInt16":
+								case "System.UInt32":
+								case "System.UInt64": return $"cast({getExp(callExp.Arguments[0])} as number)";
+								case "System.Guid": return $"substr(to_char({getExp(callExp.Arguments[0])}), 1, 36)";
+							}
+							break;
+						case "NewGuid":
+							break;
+						case "Next":
+							if (callExp.Object?.Type == typeof(Random)) return "cast(dbms_random.value*1000000000 as smallint)";
+							break;
+						case "NextDouble":
+							if (callExp.Object?.Type == typeof(Random)) return "dbms_random.value";
+							break;
+						case "Random":
+							if (callExp.Method.DeclaringType.IsNumberType()) return "dbms_random.value";
+							break;
+						case "ToString":
+							if (callExp.Object != null) return $"to_char({getExp(callExp.Object)})";
+							break;
+					}
+
+					var objExp = callExp.Object;
+					var objType = objExp?.Type;
+					if (objType?.FullName == "System.Byte[]") return null;
+
+					var argIndex = 0;
+					if (objType == null && callExp.Method.DeclaringType == typeof(Enumerable)) {
+						objExp = callExp.Arguments.FirstOrDefault();
+						objType = objExp?.Type;
+						argIndex++;
+					}
+					if (objType == null) objType = callExp.Method.DeclaringType;
+					if (objType != null || objType.IsArray || typeof(IList).IsAssignableFrom(callExp.Method.DeclaringType)) {
+						var left = objExp == null ? null : getExp(objExp);
+						switch (callExp.Method.Name) {
+							case "Contains":
+								//判断 in
+								return $"({getExp(callExp.Arguments[argIndex])}) in {left}";
+						}
+					}
+					break;
+				case ExpressionType.NewArrayInit:
+					var arrExp = exp as NewArrayExpression;
+					var arrSb = new StringBuilder();
+					arrSb.Append("(");
+					for (var a = 0; a < arrExp.Expressions.Count; a++) {
+						if (a > 0) arrSb.Append(",");
+						arrSb.Append(getExp(arrExp.Expressions[a]));
+					}
+					if (arrSb.Length == 1) arrSb.Append("NULL");
+					return arrSb.Append(")").ToString();
+				case ExpressionType.ListInit:
+					var listExp = exp as ListInitExpression;
+					var listSb = new StringBuilder();
+					listSb.Append("(");
+					for (var a = 0; a < listExp.Initializers.Count; a++) {
+						if (listExp.Initializers[a].Arguments.Any() == false) continue;
+						if (a > 0) listSb.Append(",");
+						listSb.Append(getExp(listExp.Initializers[a].Arguments.FirstOrDefault()));
+					}
+					if (listSb.Length == 1) listSb.Append("NULL");
+					return listSb.Append(")").ToString();
+				case ExpressionType.New:
+					var newExp = exp as NewExpression;
+					if (typeof(IList).IsAssignableFrom(newExp.Type)) {
+						if (newExp.Arguments.Count == 0) return "(NULL)";
+						if (typeof(IEnumerable).IsAssignableFrom(newExp.Arguments[0].Type) == false) return "(NULL)";
+						return getExp(newExp.Arguments[0]);
+					}
+					return null;
+			}
+			return null;
+		}
+
+		public override string ExpressionLambdaToSqlMemberAccessString(MemberExpression exp, ExpTSC tsc) {
+			if (exp.Expression == null) {
+				switch (exp.Member.Name) {
+					case "Empty": return "''";
+				}
+				return null;
+			}
+			var left = ExpressionLambdaToSql(exp.Expression, tsc);
+			switch (exp.Member.Name) {
+				case "Length": return $"length({left})";
+			}
+			return null;
+		}
+		public override string ExpressionLambdaToSqlMemberAccessDateTime(MemberExpression exp, ExpTSC tsc) {
+			if (exp.Expression == null) {
+				switch (exp.Member.Name) {
+					case "Now": return "systimestamp";
+					case "UtcNow": return "sys_extract_utc(systimestamp)";
+					case "Today": return "trunc(systimestamp)";
+					case "MinValue": return "to_timestamp('0001-01-01 00:00:00','YYYY-MM-DD HH24:MI:SS.FF6')";
+					case "MaxValue": return "to_timestamp('9999-12-31 23:59:59','YYYY-MM-DD HH24:MI:SS.FF6')";
+				}
+				return null;
+			}
+			var left = ExpressionLambdaToSql(exp.Expression, tsc);
+			switch (exp.Member.Name) {
+				case "Date": return $"trunc({left})";
+				case "TimeOfDay": return $"({left}-trunc({left}))";
+				case "DayOfWeek": return $"case when to_char({left})='7' then 0 else cast(to_char({left}) as number) end";
+				case "Day": return $"cast(to_char({left},'DD') as number)";
+				case "DayOfYear": return $"cast(to_char({left},'DDD') as number)";
+				case "Month": return $"cast(to_char({left},'MM') as number)";
+				case "Year": return $"cast(to_char({left},'YYYY') as number)";
+				case "Hour": return $"cast(to_char({left},'HH24') as number)";
+				case "Minute": return $"cast(to_char({left},'MI') as number)";
+				case "Second": return $"cast(to_char({left},'SS') as number)";
+				case "Millisecond": return $"cast(to_char({left},'FF3') as number)";
+				case "Ticks": return $"cast(to_char({left},'FF7') as number)";
+			}
+			return null;
+		}
+		public override string ExpressionLambdaToSqlMemberAccessTimeSpan(MemberExpression exp, ExpTSC tsc) {
+			if (exp.Expression == null) {
+				switch (exp.Member.Name) {
+					case "Zero": return "numtodsinterval(0,'second')";
+					case "MinValue": return "numtodsinterval(-233720368.5477580,'second')";
+					case "MaxValue": return "numtodsinterval(233720368.5477580,'second')";
+				}
+				return null;
+			}
+			var left = ExpressionLambdaToSql(exp.Expression, tsc);
+			switch (exp.Member.Name) {
+				case "Days": return $"extract(day from {left})";
+				case "Hours": return $"extract(hour from {left})";
+				case "Milliseconds": return $"cast(substr(extract(second from {left})-floor(extract(second from {left})),2,3) as number)";
+				case "Minutes": return $"extract(minute from {left})";
+				case "Seconds": return $"floor(extract(second from {left}))";
+				case "Ticks": return $"(extract(day from {left})*86400+extract(hour from {left})*3600+extract(minute from {left})*60+extract(second from {left}))*10000000";
+				case "TotalDays": return $"extract(day from {left})";
+				case "TotalHours": return $"(extract(day from {left})*24+extract(hour from {left}))";
+				case "TotalMilliseconds": return $"(extract(day from {left})*86400+extract(hour from {left})*3600+extract(minute from {left})*60+extract(second from {left}))*1000";
+				case "TotalMinutes": return $"(extract(day from {left})*1440+extract(hour from {left})*60+extract(minute from {left}))";
+				case "TotalSeconds": return $"(extract(day from {left})*86400+extract(hour from {left})*3600+extract(minute from {left})*60+extract(second from {left}))";
+			}
+			return null;
+		}
+
+		public override string ExpressionLambdaToSqlCallString(MethodCallExpression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			if (exp.Object == null) {
+				switch (exp.Method.Name) {
+					case "IsNullOrEmpty":
+						var arg1 = getExp(exp.Arguments[0]);
+						return $"({arg1} is null or {arg1} = '')";
+					case "Concat":
+						return _common.StringConcat(exp.Arguments.Select(a => getExp(a)).ToArray(), null);
+				}
+			} else {
+				var left = getExp(exp.Object);
+				switch (exp.Method.Name) {
+					case "StartsWith":
+					case "EndsWith":
+					case "Contains":
+						var args0Value = getExp(exp.Arguments[0]);
+						if (args0Value == "NULL") return $"({left}) IS NULL";
+						if (exp.Method.Name == "StartsWith") return $"({left}) LIKE {(args0Value.EndsWith("'") ? args0Value.Insert(args0Value.Length - 1, "%") : $"(to_char({args0Value})||'%')")}";
+						if (exp.Method.Name == "EndsWith") return $"({left}) LIKE {(args0Value.StartsWith("'") ? args0Value.Insert(1, "%") : $"('%'||to_char({args0Value}))")}";
+						if (args0Value.StartsWith("'") && args0Value.EndsWith("'")) return $"({left}) LIKE {args0Value.Insert(1, "%").Insert(args0Value.Length, "%")}";
+						return $"({left}) LIKE ('%'||to_char({args0Value})||'%')";
+					case "ToLower": return $"lower({left})";
+					case "ToUpper": return $"upper({left})";
+					case "Substring":
+						var substrArgs1 = getExp(exp.Arguments[0]);
+						if (long.TryParse(substrArgs1, out var testtrylng1)) substrArgs1 = (testtrylng1 + 1).ToString();
+						else substrArgs1 += "+1";
+						if (exp.Arguments.Count == 1) return $"substr({left}, {substrArgs1})";
+						return $"substr({left}, {substrArgs1}, {getExp(exp.Arguments[1])})";
+					case "IndexOf":
+						var indexOfFindStr = getExp(exp.Arguments[0]);
+						if (exp.Arguments.Count > 1 && exp.Arguments[1].Type.FullName == "System.Int32") {
+							var locateArgs1 = getExp(exp.Arguments[1]);
+							if (long.TryParse(locateArgs1, out var testtrylng2)) locateArgs1 = (testtrylng2 + 1).ToString();
+							else locateArgs1 += "+1";
+							return $"(instr({left}, {indexOfFindStr}, {locateArgs1}, 1)-1)";
+						}
+						return $"(instr({left}, {indexOfFindStr}, 1, 1))-1";
+					case "PadLeft":
+						if (exp.Arguments.Count == 1) return $"lpad({left}, {getExp(exp.Arguments[0])}, ' ')";
+						return $"lpad({left}, {getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+					case "PadRight":
+						if (exp.Arguments.Count == 1) return $"rpad({left}, {getExp(exp.Arguments[0])}, ' ')";
+						return $"rpad({left}, {getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+					case "Trim":
+					case "TrimStart":
+					case "TrimEnd":
+						if (exp.Arguments.Count == 0) {
+							if (exp.Method.Name == "Trim") return $"trim({left})";
+							if (exp.Method.Name == "TrimStart") return $"ltrim({left})";
+							if (exp.Method.Name == "TrimEnd") return $"rtrim({left})";
+						}
+						foreach (var argsTrim02 in exp.Arguments) {
+							var argsTrim01s = new[] { argsTrim02 };
+							if (argsTrim02.NodeType == ExpressionType.NewArrayInit) {
+								var arritem = argsTrim02 as NewArrayExpression;
+								argsTrim01s = arritem.Expressions.ToArray();
+							}
+							foreach (var argsTrim01 in argsTrim01s) {
+								if (exp.Method.Name == "Trim") left = $"trim(both {getExp(argsTrim01)} from {left})";
+								if (exp.Method.Name == "TrimStart") left = $"ltrim({left},{getExp(argsTrim01)})";
+								if (exp.Method.Name == "TrimEnd") left = $"rtrim({left},{getExp(argsTrim01)})";
+							}
+						}
+						return left;
+					case "Replace": return $"replace({left}, {getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+					case "CompareTo": return $"case when {left} = {getExp(exp.Arguments[0])} then 0 when {left} > {getExp(exp.Arguments[0])} then 1 else -1 end";
+					case "Equals": return $"({left} = {getExp(exp.Arguments[0])})";
+				}
+			}
+			throw new Exception($"OracleExpression 未实现函数表达式 {exp} 解析");
+		}
+		public override string ExpressionLambdaToSqlCallMath(MethodCallExpression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			switch (exp.Method.Name) {
+				case "Abs": return $"abs({getExp(exp.Arguments[0])})";
+				case "Sign": return $"sign({getExp(exp.Arguments[0])})";
+				case "Floor": return $"floor({getExp(exp.Arguments[0])})";
+				case "Ceiling": return $"ceil({getExp(exp.Arguments[0])})";
+				case "Round":
+					if (exp.Arguments.Count > 1 && exp.Arguments[1].Type.FullName == "System.Int32") return $"round({getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+					return $"round({getExp(exp.Arguments[0])})";
+				case "Exp": return $"exp({getExp(exp.Arguments[0])})";
+				case "Log": if (exp.Arguments.Count > 1) return $"log({getExp(exp.Arguments[1])},{getExp(exp.Arguments[0])})";
+					return $"log(2.7182818284590451,{getExp(exp.Arguments[0])})";
+				case "Log10": return $"log(10,{getExp(exp.Arguments[0])})";
+				case "Pow": return $"power({getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+				case "Sqrt": return $"sqrt({getExp(exp.Arguments[0])})";
+				case "Cos": return $"cos({getExp(exp.Arguments[0])})";
+				case "Sin": return $"sin({getExp(exp.Arguments[0])})";
+				case "Tan": return $"tan({getExp(exp.Arguments[0])})";
+				case "Acos": return $"acos({getExp(exp.Arguments[0])})";
+				case "Asin": return $"asin({getExp(exp.Arguments[0])})";
+				case "Atan": return $"atan({getExp(exp.Arguments[0])})";
+				//case "Atan2": return $"atan2({getExp(exp.Arguments[0])}, {getExp(exp.Arguments[1])})";
+				case "Truncate": return $"trunc({getExp(exp.Arguments[0])}, 0)";
+			}
+			throw new Exception($"OracleExpression 未实现函数表达式 {exp} 解析");
+		}
+		public override string ExpressionLambdaToSqlCallDateTime(MethodCallExpression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			if (exp.Object == null) {
+				switch (exp.Method.Name) {
+					case "Compare": return $"extract(day from ({getExp(exp.Arguments[0])}-({getExp(exp.Arguments[1])})))";
+					case "DaysInMonth": return $"cast(to_char(last_day(({getExp(exp.Arguments[0])})||'-'||({getExp(exp.Arguments[1])})||'-01'),'DD') as number)";
+					case "Equals": return $"({getExp(exp.Arguments[0])} = {getExp(exp.Arguments[1])})";
+
+					case "IsLeapYear":
+						var isLeapYearArgs1 = getExp(exp.Arguments[0]);
+						return $"(mod({isLeapYearArgs1},4)=0 AND mod({isLeapYearArgs1},100)<>0 OR mod({isLeapYearArgs1},400)=0)";
+
+					case "Parse": return $"to_timestamp({getExp(exp.Arguments[0])},'YYYY-MM-DD HH24:MI:SS.FF6')";
+					case "ParseExact":
+					case "TryParse":
+					case "TryParseExact": return $"to_timestamp({getExp(exp.Arguments[0])},'YYYY-MM-DD HH24:MI:SS.FF6')";
+				}
+			} else {
+				var left = getExp(exp.Object);
+				var args1 = exp.Arguments.Count == 0 ? null : getExp(exp.Arguments[0]);
+				switch (exp.Method.Name) {
+					case "Add": return $"({left}+{args1})";
+					case "AddDays": return $"({left}+{args1})";
+					case "AddHours": return $"({left}+({args1})/24)";
+					case "AddMilliseconds": return $"({left}+({args1})/86400000)";
+					case "AddMinutes": return $"({left}+({args1})/1440)";
+					case "AddMonths": return $"add_months({left},{args1})";
+					case "AddSeconds": return $"({left}+({args1})/86400)";
+					case "AddTicks": return $"({left}+({args1})/864000000000)";
+					case "AddYears": return $"add_months({left},({args1})*12)";
+					case "Subtract":
+						switch ((exp.Arguments[0].Type.IsNullableType() ? exp.Arguments[0].Type.GenericTypeArguments.FirstOrDefault() : exp.Arguments[0].Type).FullName) {
+							case "System.DateTime": return $"({args1}-{left})";
+							case "System.TimeSpan": return $"({left}-{args1})";
+						}
+						break;
+					case "Equals": return $"({left} = {getExp(exp.Arguments[0])})";
+					case "CompareTo": return $"extract(day from ({left}-({getExp(exp.Arguments[0])})))";
+					case "ToString": return $"to_char({left},'YYYY-MM-DD HH24:MI:SS.FF6')";
+				}
+			}
+			throw new Exception($"OracleExpression 未实现函数表达式 {exp} 解析");
+		}
+		public override string ExpressionLambdaToSqlCallTimeSpan(MethodCallExpression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			if (exp.Object == null) {
+				switch (exp.Method.Name) {
+					case "Compare": return $"extract(day from ({getExp(exp.Arguments[0])}-({getExp(exp.Arguments[1])})))";
+					case "Equals": return $"({getExp(exp.Arguments[0])} = {getExp(exp.Arguments[1])})";
+					case "FromDays": return $"numtodsinterval(({getExp(exp.Arguments[0])})*{(long)60 * 60 * 24},'second')";
+					case "FromHours": return $"numtodsinterval(({getExp(exp.Arguments[0])})*{(long)60 * 60},'second')";
+					case "FromMilliseconds": return $"numtodsinterval(({getExp(exp.Arguments[0])})/1000,'second')";
+					case "FromMinutes": return $"numtodsinterval(({getExp(exp.Arguments[0])})*60,'second')";
+					case "FromSeconds": return $"numtodsinterval(({getExp(exp.Arguments[0])}),'second')";
+					case "FromTicks": return $"numtodsinterval(({getExp(exp.Arguments[0])})/10000000,'second')";
+					case "Parse": return $"cast({getExp(exp.Arguments[0])} as interval day(9) to second(7))";
+					case "ParseExact":
+					case "TryParse":
+					case "TryParseExact": return $"cast({getExp(exp.Arguments[0])} as interval day(9) to second(7))";
+				}
+			} else {
+				var left = getExp(exp.Object);
+				var args1 = exp.Arguments.Count == 0 ? null : getExp(exp.Arguments[0]);
+				switch (exp.Method.Name) {
+					case "Add": return $"({left}+{args1})";
+					case "Subtract": return $"({left}-({args1}))";
+					case "Equals": return $"({left} = {getExp(exp.Arguments[0])})";
+					case "CompareTo": return $"extract(day from ({left}-({getExp(exp.Arguments[0])})))";
+					case "ToString": return $"to_char({left})";
+				}
+			}
+			throw new Exception($"OracleExpression 未实现函数表达式 {exp} 解析");
+		}
+		public override string ExpressionLambdaToSqlCallConvert(MethodCallExpression exp, ExpTSC tsc) {
+			Func<Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
+			if (exp.Object == null) {
+				switch (exp.Method.Name) {
+					//case "ToBoolean": return $"({getExp(exp.Arguments[0])} not in ('0','false'))";
+					case "ToByte": return $"cast({getExp(exp.Arguments[0])} as number)";
+					case "ToChar": return $"substr(to_char({getExp(exp.Arguments[0])}), 1, 1)";
+					case "ToDateTime": return $"to_timestamp({getExp(exp.Arguments[0])},'YYYY-MM-DD HH24:MI:SS.FF6')";
+					case "ToDecimal": return $"cast({getExp(exp.Arguments[0])} as number)";
+					case "ToDouble": return $"cast({getExp(exp.Arguments[0])} as number)";
+					case "ToInt16": 
+					case "ToInt32": 
+					case "ToInt64":
+					case "ToSByte": return $"cast({getExp(exp.Arguments[0])} as number)";
+					case "ToSingle": return $"cast({getExp(exp.Arguments[0])} as number)";
+					case "ToString": return $"to_char({getExp(exp.Arguments[0])})";
+					case "ToUInt16":
+					case "ToUInt32":
+					case "ToUInt64": return $"cast({getExp(exp.Arguments[0])} as number)";
+				}
+			}
+			throw new Exception($"OracleExpression 未实现函数表达式 {exp} 解析");
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleExtensions.cs

@@ -0,0 +1,11 @@
+public static partial class FreeSqlGlobalExtensions {
+
+	/// <summary>
+	/// 特殊处理类似 string.Format 的使用方法，防止注入，以及 IS NULL 转换
+	/// </summary>
+	/// <param name="that"></param>
+	/// <param name="args"></param>
+	/// <returns></returns>
+	public static string FormatOracleSQL(this string that, params object[] args) => _oracleAdo.Addslashes(that, args);
+	static FreeSql.Oracle.OracleAdo _oracleAdo = new FreeSql.Oracle.OracleAdo();
+}

Providers/FreeSql.Provider.Oracle/OracleProvider.cs

@@ -0,0 +1,54 @@
+using FreeSql.Internal;
+using FreeSql.Internal.CommonProvider;
+using FreeSql.Oracle.Curd;
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+
+namespace FreeSql.Oracle {
+
+	public class OracleProvider<TMark> : IFreeSql<TMark> {
+
+		public ISelect<T1> Select<T1>() where T1 : class => new OracleSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null);
+		public ISelect<T1> Select<T1>(object dywhere) where T1 : class => new OracleSelect<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, dywhere);
+		public IInsert<T1> Insert<T1>() where T1 : class => new OracleInsert<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression);
+		public IInsert<T1> Insert<T1>(T1 source) where T1 : class => this.Insert<T1>().AppendData(source);
+		public IInsert<T1> Insert<T1>(T1[] source) where T1 : class => this.Insert<T1>().AppendData(source);
+		public IInsert<T1> Insert<T1>(IEnumerable<T1> source) where T1 : class => this.Insert<T1>().AppendData(source);
+		public IUpdate<T1> Update<T1>() where T1 : class => new OracleUpdate<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null);
+		public IUpdate<T1> Update<T1>(object dywhere) where T1 : class => new OracleUpdate<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, dywhere);
+		public IDelete<T1> Delete<T1>() where T1 : class => new OracleDelete<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, null);
+		public IDelete<T1> Delete<T1>(object dywhere) where T1 : class => new OracleDelete<T1>(this, this.InternalCommonUtils, this.InternalCommonExpression, dywhere);
+
+		public IAdo Ado { get; }
+		public IAop Aop { get; }
+		public ICodeFirst CodeFirst { get; }
+		public IDbFirst DbFirst { get; }
+		public OracleProvider(string masterConnectionString, string[] slaveConnectionString) {
+			this.InternalCommonUtils = new OracleUtils(this);
+			this.InternalCommonExpression = new OracleExpression(this.InternalCommonUtils);
+
+			this.Ado = new OracleAdo(this.InternalCommonUtils, masterConnectionString, slaveConnectionString);
+			this.Aop = new AopProvider();
+
+			this.DbFirst = new OracleDbFirst(this, this.InternalCommonUtils, this.InternalCommonExpression);
+			this.CodeFirst = new OracleCodeFirst(this, this.InternalCommonUtils, this.InternalCommonExpression);
+		}
+
+		internal CommonUtils InternalCommonUtils { get; }
+		internal CommonExpression InternalCommonExpression { get; }
+
+		public void Transaction(Action handler) => Ado.Transaction(handler);
+
+		public void Transaction(Action handler, TimeSpan timeout) => Ado.Transaction(handler, timeout);
+
+		~OracleProvider() {
+			this.Dispose();
+		}
+		bool _isdisposed = false;
+		public void Dispose() {
+			if (_isdisposed) return;
+			(this.Ado as AdoProvider).Dispose();
+		}
+	}
+}

Providers/FreeSql.Provider.Oracle/OracleUtils.cs

@@ -0,0 +1,76 @@
+using FreeSql.Internal;
+using FreeSql.Internal.Model;
+using Oracle.ManagedDataAccess.Client;
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace FreeSql.Oracle {
+
+	class OracleUtils : CommonUtils {
+		public OracleUtils(IFreeSql orm) : base(orm) {
+		}
+
+		public override DbParameter AppendParamter(List<DbParameter> _params, string parameterName, Type type, object value) {
+			if (string.IsNullOrEmpty(parameterName)) parameterName = $"p_{_params?.Count}";
+			var dbtype = (OracleDbType)_orm.CodeFirst.GetDbInfo(type)?.type;
+			if (dbtype == OracleDbType.Boolean) {
+				if (value == null) value = null;
+				else value = (bool)value == true ? 1 : 0;
+				dbtype = OracleDbType.Int16;
+			}
+			var ret = new OracleParameter { ParameterName = QuoteParamterName(parameterName), OracleDbType = dbtype, Value = value };
+			_params?.Add(ret);
+			return ret;
+		}
+
+		public override DbParameter[] GetDbParamtersByObject(string sql, object obj) =>
+			Utils.GetDbParamtersByObject<OracleParameter>(sql, obj, ":", (name, type, value) => {
+				var dbtype = (OracleDbType)_orm.CodeFirst.GetDbInfo(type)?.type;
+				if (dbtype == OracleDbType.Boolean) {
+					if (value == null) value = null;
+					else value = (bool)value == true ? 1 : 0;
+					dbtype = OracleDbType.Int16;
+				}
+				var ret = new OracleParameter { ParameterName = $":{name}", OracleDbType = dbtype, Value = value };
+				return ret;
+			});
+
+		public override string FormatSql(string sql, params object[] args) => sql?.FormatOracleSQL(args);
+		public override string QuoteSqlName(string name) {
+			var nametrim = name.Trim();
+			if (nametrim.StartsWith("(") && nametrim.EndsWith(")"))
+				return nametrim; //原生SQL
+			return $"\"{nametrim.Trim('"').Replace(".", "\".\"")}\"";
+		}
+		public override string TrimQuoteSqlName(string name) {
+			var nametrim = name.Trim();
+			if (nametrim.StartsWith("(") && nametrim.EndsWith(")"))
+				return nametrim; //原生SQL
+			return $"{nametrim.Trim('"').Replace("\".\"", ".").Replace(".\"", ".")}";
+		}
+		public override string QuoteParamterName(string name) => $":{(_orm.CodeFirst.IsSyncStructureToLower ? name.ToLower() : name)}";
+		public override string IsNull(string sql, object value) => $"nvl({sql}, {value})";
+		public override string StringConcat(string[] objs, Type[] types) => $"{string.Join(" || ", objs)}";
+		public override string Mod(string left, string right, Type leftType, Type rightType) => $"mod({left}, {right})";
+
+		public override string QuoteWriteParamter(Type type, string paramterName) => paramterName;
+		public override string QuoteReadColumn(Type type, string columnName) => columnName;
+
+		public override string GetNoneParamaterSqlValue(List<DbParameter> specialParams, Type type, object value) {
+			if (value == null) return "NULL";
+			if (type == typeof(byte[])) {
+				var bytes = value as byte[];
+				var sb = new StringBuilder().Append("rawtohex('0x");
+				foreach (var vc in bytes) {
+					if (vc < 10) sb.Append("0");
+					sb.Append(vc.ToString("X"));
+				}
+				return sb.Append("')").ToString();
+			}
+			return FormatSql("{0}", value, 1);
+		}
+	}
+}