public override IDataReader GetDataReader(MappingSchema schema, IDataReader dataReader)
{
return
dataReader is NpgsqlDataReader
? new NpgsqlDataReaderEx(schema, (NpgsqlDataReader)dataReader)
: base.GetDataReader(schema, dataReader);
}
protected SqlCeDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsSubQueryColumnSupported = false;
SetCharField("NChar", (r,i) => r.GetString(i).TrimEnd());
}
public void BaseSchema2()
{
var ms1 = new MappingSchema();
var ms2 = new MappingSchema(ms1);
Convert<DateTime,string>.Lambda = d => d.ToString(DateTimeFormatInfo.InvariantInfo);
ms1.SetConverter<DateTime,string>(d => d.ToString(new CultureInfo("en-US", false).DateTimeFormat));
ms2.SetConverter<DateTime,string>(d => d.ToString(new CultureInfo("ru-RU", false).DateTimeFormat));
{
var c0 = Convert<DateTime,string>.Lambda;
var c1 = ms1.GetConverter<DateTime,string>();
var c2 = ms2.GetConverter<DateTime,string>();
Assert.AreEqual("01/20/2012 16:30:40", c0(new DateTime(2012, 1, 20, 16, 30, 40, 50, DateTimeKind.Utc)));
Assert.AreEqual("1/20/2012 4:30:40 PM", c1(new DateTime(2012, 1, 20, 16, 30, 40, 50, DateTimeKind.Utc)));
Assert.AreEqual("20.01.2012 16:30:40", c2(new DateTime(2012, 1, 20, 16, 30, 40, 50, DateTimeKind.Utc)));
}
Convert<string,DateTime>.Expression = s => DateTime.Parse(s, DateTimeFormatInfo.InvariantInfo);
ms1.SetConvertExpression<string,DateTime>(s => DateTime.Parse(s, new CultureInfo("en-US", false).DateTimeFormat));
ms2.SetConvertExpression<string,DateTime>(s => DateTime.Parse(s, new CultureInfo("ru-RU", false).DateTimeFormat));
{
var c0 = Convert<string,DateTime>.Lambda;
var c1 = ms1.GetConverter<string,DateTime>();
var c2 = ms2.GetConverter<string,DateTime>();
Assert.AreEqual(new DateTime(2012, 1, 20, 16, 30, 40), c0("01/20/2012 16:30:40"));
Assert.AreEqual(new DateTime(2012, 1, 20, 16, 30, 40), c1("1/20/2012 4:30:40 PM"));
Assert.AreEqual(new DateTime(2012, 1, 20, 16, 30, 40), c2("20.01.2012 16:30:40"));
}
}
public bool InitGenericConvertProvider(Type[] types, MappingSchema mappingSchema)
{
var changed = false;
if (_genericConvertProviders != null)
{
lock (_genericConvertProviders)
{
foreach (var type in _genericConvertProviders)
{
var args = type.Key.GetGenericArgumentsEx();
if (args.Length == types.Length)
{
if (type.Value.Aggregate(false, (cur,ts) => cur || ts.SequenceEqual(types)))
continue;
var gtype = type.Key.MakeGenericType(types);
var provider = (IGenericInfoProvider)Activator.CreateInstance(gtype);
provider.SetInfo(new MappingSchema(this));
type.Value.Add(types);
changed = true;
}
}
}
}
return changed;
}
protected FirebirdDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SetCharField("CHAR", (r,i) => r.GetString(i).TrimEnd());
SetProviderField<IDataReader,TimeSpan,DateTime>((r,i) => r.GetDateTime(i) - new DateTime(1970, 1, 1));
SetProviderField<IDataReader,DateTime,DateTime>((r,i) => GetDateTime(r, i));
}
public FullMappingSchema(DbManager db, bool ignoreLazyLoad = false, MappingSchema parentMappingSchema = null,
FactoryType factoryType = FactoryType.LazyLoading)
{
_db = db;
_parentMappingSchema = parentMappingSchema;
_factoryType = factoryType;
_ignoreLazyLoad = ignoreLazyLoad;
}
protected DB2DataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.AcceptsTakeAsParameterIfSkip = true;
SetCharField("CHAR", (r,i) => r.GetString(i).TrimEnd());
}
public ScalarDataReaderMapper(
MappingSchema mappingSchema,
IDataReader dataReader,
NameOrIndexParameter nameOrIndex)
: base(mappingSchema, dataReader)
{
_index = nameOrIndex.ByName? dataReader.GetOrdinal(nameOrIndex.Name): nameOrIndex.Index;
}
public ServiceModelDataReader(MappingSchema mappingSchema, LinqServiceResult result)
{
_mappingSchema = mappingSchema;
_result = result;
for (var i = 0; i < result.FieldNames.Length; i++)
_ordinal.Add(result.FieldNames[i], i);
}
protected OracleDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.MaxInListValuesCount = 1000;
SetCharField("Char", (r,i) => r.GetString(i).TrimEnd());
SetCharField("NChar", (r,i) => r.GetString(i).TrimEnd());
}
public override void SetTable(MappingSchema mappingSchema, SqlTable table, MemberInfo member, IEnumerable<Expression> arguments, IEnumerable<ISqlExpression> sqlArgs)
{
table.SqlTableType = SqlTableType.Expression;
table.Name = Expression ?? member.Name;
table.TableArguments = ConvertArgs(member, sqlArgs.ToArray());
if (Schema != null) table.Owner = Schema;
if (Database != null) table.Database = Database;
}
protected SQLiteDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsSkipSupported = false;
SqlProviderFlags.IsSkipSupportedIfTake = true;
SetCharField("char", (r,i) => r.GetString(i).TrimEnd());
SetCharField("nchar", (r,i) => r.GetString(i).TrimEnd());
}
//[Test]
public void ObjToDicTest()
{
var obj = new TestObj { Country = CountryCodeEnum1.DZ, Other = OtherEnum1.EnumValue2 };
var sh = new MappingSchema { Extensions = TypeExtension.GetExtensions("Map.xml") };
var pars = sh.MapObjectToDictionary(obj);
Assert.AreEqual("DZ", pars["country_code"]);
Assert.AreEqual(101, pars["other"]);
}
protected PostgreSQLDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SetCharField("bpchar", (r,i) => r.GetString(i).TrimEnd());
_sqlOptimizer = new PostgreSQLSqlOptimizer(SqlProviderFlags);
}
public LambdaInfo Create(MappingSchema mappingSchema, Type from, Type to)
{
var ex = ConvertBuilder.GetConverter(mappingSchema, from, to);
var lm = ex.Item1.Compile();
var ret = new LambdaInfo(ex.Item1, ex.Item2, lm, ex.Item3);
Set(_expressions, from, to , ret);
return ret;
}
public EntityDescriptor(MappingSchema mappingSchema, Type type)
{
_mappingSchema = mappingSchema;
TypeAccessor = TypeAccessor.GetAccessor(type);
Associations = new List<AssociationDescriptor>();
Columns = new List<ColumnDescriptor>();
Init();
}
public void DefaultValue1()
{
var ms = new MappingSchema();
ms.SetDefaultValue(typeof(int), -1);
var c = ms.GetConverter<int?,int>();
Assert.AreEqual(-1, c(null));
}
public override void Init(MappingSchema mappingSchema, Type type)
{
PropertyType = type;
// TODO implement this method
base.Init(mappingSchema, type);
int startIndex = 0;
GetObjectMapper(this, ref startIndex, _typeAccessor);
}
public void Test()
{
var schema = new MappingSchema();
schema.SetDataType(typeof (decimal), new SqlDataType(DataType.Decimal, 19, 4));
var table = new SqlTable<Foo>(schema);
Assert.That(table.Fields.Single().Value.Precision, Is.EqualTo(19));
Assert.That(table.Fields.Single().Value.Scale, Is.EqualTo(4));
}
public void AddAtribute2()
{
var ms = new MappingSchema();
var mb = ms.GetFluentMappingBuilder();
mb.HasAttribute<MyClass>(new TableAttribute("NewName") { Configuration = "Test"});
var ed = ms.GetEntityDescriptor(typeof(MyClass));
Assert.That(ed.TableName, Is.EqualTo("MyClass"));
}
public TextDataReader(Stream stream, MappingSchema mappingSchema)
{
GC.SuppressFinalize(this);
if (mappingSchema == null) throw new ArgumentNullException("mappingSchema");
_reader = new StreamReader(stream);
_mappingSchema = mappingSchema;
ReadHeader();
}
protected AccessDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.AcceptsTakeAsParameter = false;
SqlProviderFlags.IsSkipSupported = false;
SetCharField("DBTYPE_WCHAR", (r,i) => r.GetString(i).TrimEnd());
SetProviderField<IDataReader,TimeSpan,DateTime>((r,i) => r.GetDateTime(i) - new DateTime(1899, 12, 30));
SetProviderField<IDataReader,DateTime,DateTime>((r,i) => GetDateTime(r, i));
}
void SetEnumConverterInternal(MemberAccessor ma, MappingSchema ms)
{
if (_valueConverter == null)
{
_valueConverter = o => ms.MapEnumToValue(o, ma, true);
}
else
{
var converter = _valueConverter;
_valueConverter = o => ms.MapEnumToValue(converter(o), ma, true);
}
}
protected FirebirdDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsIdentityParameterRequired = true;
SetCharField("CHAR", (r,i) => r.GetString(i).TrimEnd());
SetProviderField<IDataReader,TimeSpan,DateTime>((r,i) => r.GetDateTime(i) - new DateTime(1970, 1, 1));
SetProviderField<IDataReader,DateTime,DateTime>((r,i) => GetDateTime(r, i));
_sqlOptimizer = new FirebirdSqlOptimizer(SqlProviderFlags);
}
public override void SetTable(MappingSchema mappingSchema, SqlTable table, MemberInfo member, IEnumerable<Expression> expArgs, IEnumerable<ISqlExpression> sqlArgs)
{
var aargs = sqlArgs.ToArray();
var arr = ConvertArgs(member, aargs).ToList();
var method = (MethodInfo)member;
{
var ttype = method.GetGenericArguments()[0];
var tbl = new SqlTable(ttype);
var database = Convert(tbl.Database);
var owner = Convert(tbl.Owner);
var physicalName = Convert(tbl.PhysicalName);
var name = "";
if (database != null)
name = database + "." + (owner == null ? "." : owner + ".");
else if (owner != null)
name = owner + ".";
name += physicalName;
arr.Add(new SqlExpression(name, Precedence.Primary));
}
{
var field = ((ConstantExpression)expArgs.First()).Value;
if (field is string)
{
arr[0] = new SqlExpression(field.ToString(), Precedence.Primary);
}
else if (field is LambdaExpression)
{
var body = ((LambdaExpression)field).Body;
if (body is MemberExpression)
{
var name = ((MemberExpression)body).Member.Name;
if (name.Length > 0 && name[0] != '[')
name = "[" + name + "]";
arr[0] = new SqlExpression(name, Precedence.Primary);
}
}
}
table.SqlTableType = SqlTableType.Expression;
table.Name = "FREETEXTTABLE({6}, {2}, {3}) {1}";
table.TableArguments = arr.ToArray();
}
protected SqlCeDataProvider(string name, MappingSchema mappingSchema)
: base(name, mappingSchema)
{
SqlProviderFlags.IsSubQueryColumnSupported = false;
SqlProviderFlags.IsCountSubQuerySupported = false;
SqlProviderFlags.IsApplyJoinSupported = true;
SqlProviderFlags.IsInsertOrUpdateSupported = false;
SetCharField("NChar", (r,i) => r.GetString(i).TrimEnd());
_sqlOptimizer = new SqlCeSqlOptimizer(SqlProviderFlags);
}
public void Assosiation()
{
var ms = new MappingSchema();
var mb = ms.GetFluentMappingBuilder();
mb.Entity<MyClass>()
.Property(e => e.Parent)
.HasAttribute(new AssociationAttribute { ThisKey = "ID", OtherKey = "ID1" });
var ed = ms.GetEntityDescriptor(typeof(MyClass));
Assert.That(ed.Associations, Is.Not.EqualTo(0));
}
public TextDataWriter(TextWriter writer, MappingSchema mappingSchema, params string[] fieldNames)
{
GC.SuppressFinalize(this);
if (mappingSchema == null) throw new ArgumentNullException("mappingSchema");
_writer = writer;
_names = fieldNames;
_values = new string[_names.Length];
WriteHeader();
}
public SqlServer2012SqlBuilder(MappingSchema mappingSchema, ISqlOptimizer sqlOptimizer, SqlProviderFlags sqlProviderFlags)
: base(null, mappingSchema, sqlOptimizer, sqlProviderFlags)
{
}
public static NpgsqlProviderAdapter GetInstance()
{
if (_instance == null)
{
lock (_syncRoot)
if (_instance == null)
{
var assembly = Tools.TryLoadAssembly(AssemblyName, null);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {AssemblyName}");
}
var connectionType = assembly.GetType($"{ClientNamespace}.NpgsqlConnection", true);
var parameterType = assembly.GetType($"{ClientNamespace}.NpgsqlParameter", true);
var dataReaderType = assembly.GetType($"{ClientNamespace}.NpgsqlDataReader", true);
var commandType = assembly.GetType($"{ClientNamespace}.NpgsqlCommand", true);
var transactionType = assembly.GetType($"{ClientNamespace}.NpgsqlTransaction", true);
var dbType = assembly.GetType($"{TypesNamespace}.NpgsqlDbType", true);
var npgsqlDateType = assembly.GetType($"{TypesNamespace}.NpgsqlDate", true);
var npgsqlPointType = assembly.GetType($"{TypesNamespace}.NpgsqlPoint", true);
var npgsqlLSegType = assembly.GetType($"{TypesNamespace}.NpgsqlLSeg", true);
var npgsqlBoxType = assembly.GetType($"{TypesNamespace}.NpgsqlBox", true);
var npgsqlCircleType = assembly.GetType($"{TypesNamespace}.NpgsqlCircle", true);
var npgsqlPathType = assembly.GetType($"{TypesNamespace}.NpgsqlPath", true);
var npgsqlPolygonType = assembly.GetType($"{TypesNamespace}.NpgsqlPolygon", true);
var npgsqlLineType = assembly.GetType($"{TypesNamespace}.NpgsqlLine", true);
var npgsqlInetType = assembly.GetType($"{TypesNamespace}.NpgsqlInet", true);
var npgsqlTimeSpanType = assembly.GetType($"{TypesNamespace}.NpgsqlTimeSpan", true);
var npgsqlDateTimeType = assembly.GetType($"{TypesNamespace}.NpgsqlDateTime", true);
var npgsqlRangeTType = assembly.GetType($"{TypesNamespace}.NpgsqlRange`1", true);
var npgsqlBinaryImporterType = assembly.GetType($"{ClientNamespace}.NpgsqlBinaryImporter", true);
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <NpgsqlConnection>(connectionType);
typeMapper.RegisterTypeWrapper <NpgsqlParameter>(parameterType);
typeMapper.RegisterTypeWrapper <NpgsqlDbType>(dbType);
typeMapper.RegisterTypeWrapper <NpgsqlBinaryImporter>(npgsqlBinaryImporterType);
typeMapper.FinalizeMappings();
var paramMapper = typeMapper.Type <NpgsqlParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.NpgsqlDbType);
var pConnection = Expression.Parameter(typeof(IDbConnection));
var pCommand = Expression.Parameter(typeof(string));
var beginBinaryImport = Expression.Lambda <Func <IDbConnection, string, NpgsqlBinaryImporter> >(
typeMapper.MapExpression((IDbConnection conn, string command) => typeMapper.Wrap <NpgsqlBinaryImporter>(((NpgsqlConnection)conn).BeginBinaryImport(command)), pConnection, pCommand),
pConnection, pCommand)
.Compile();
// create mapping schema
var mappingSchema = new MappingSchema();
// date/time types
AddUdtType(npgsqlDateType);
AddUdtType(npgsqlDateTimeType);
mappingSchema.SetDataType(npgsqlTimeSpanType, DataType.Interval);
mappingSchema.SetDataType(npgsqlTimeSpanType.AsNullable(), DataType.Interval);
// NpgsqlDateTimeType => DateTimeOffset
{
var p = Expression.Parameter(npgsqlDateTimeType, "p");
var pi = p.Type.GetProperty("DateTime");
Expression expr;
if (pi != null)
{
// < 3.2.0
// https://github.com/npgsql/npgsql/commit/3894175f970b611f6428757a932b6393749da958#diff-c792076ac0455dd0f2852822ea38b0aaL166
expr = Expression.Property(p, pi);
}
else
{
// 3.2.0+
expr = Expression.Call(p, "ToDateTime", null);
}
var npgsqlDateTimeToDateTimeOffsetMapper = Expression.Lambda(
Expression.New(
MemberHelper.ConstructorOf(() => new DateTimeOffset(new DateTime())),
expr),
p);
mappingSchema.SetConvertExpression(npgsqlDateTimeType, typeof(DateTimeOffset), npgsqlDateTimeToDateTimeOffsetMapper);
}
// inet types
AddUdtType(npgsqlInetType);
AddUdtType(typeof(IPAddress));
AddUdtType(typeof(PhysicalAddress));
// npgsql4 obsoletes NpgsqlInetType and returns ValueTuple<IPAddress, int>
// still while it is here, we should be able to map it properly
// (IPAddress, int) => NpgsqlInet
{
var valueTypeType = Type.GetType("System.ValueTuple`2", false);
if (valueTypeType != null)
{
var inetTupleType = valueTypeType.MakeGenericType(typeof(IPAddress), typeof(int));
var p = Expression.Parameter(inetTupleType, "p");
var tupleToInetTypeMapper = Expression.Lambda(
Expression.New(
npgsqlInetType.GetConstructor(new[] { typeof(IPAddress), typeof(int) }),
ExpressionHelper.Field(p, "Item1"),
ExpressionHelper.Field(p, "Item2")),
p);
mappingSchema.SetConvertExpression(inetTupleType !, npgsqlInetType, tupleToInetTypeMapper);
}
}
// ranges
AddUdtType(npgsqlRangeTType);
{
void SetRangeConversion <T>(string?fromDbType = null, DataType fromDataType = DataType.Undefined, string?toDbType = null, DataType toDataType = DataType.Undefined)
{
var rangeType = npgsqlRangeTType.MakeGenericType(typeof(T));
var fromType = new DbDataType(rangeType, fromDataType, fromDbType);
var toType = new DbDataType(typeof(DataParameter), toDataType, toDbType);
var rangeParam = Expression.Parameter(rangeType, "p");
mappingSchema.SetConvertExpression(fromType, toType,
Expression.Lambda(
Expression.New(
MemberHelper.ConstructorOf(
() => new DataParameter("", null, DataType.Undefined, toDbType)),
Expression.Constant(""),
Expression.Convert(rangeParam, typeof(object)),
Expression.Constant(toDataType),
Expression.Constant(toDbType, typeof(string))
)
, rangeParam)
);
}
SetRangeConversion <byte>();
SetRangeConversion <int>();
SetRangeConversion <double>();
SetRangeConversion <float>();
SetRangeConversion <decimal>();
SetRangeConversion <DateTime>(fromDbType: "daterange", toDbType: "daterange");
SetRangeConversion <DateTime>(fromDbType: "tsrange", toDbType: "tsrange");
SetRangeConversion <DateTime>(toDbType: "tsrange");
SetRangeConversion <DateTime>(fromDbType: "tstzrange", toDbType: "tstzrange");
SetRangeConversion <DateTimeOffset>("tstzrange");
}
// spatial types
AddUdtType(npgsqlPointType);
AddUdtType(npgsqlLSegType);
AddUdtType(npgsqlBoxType);
AddUdtType(npgsqlPathType);
AddUdtType(npgsqlCircleType);
AddUdtType(npgsqlPolygonType);
AddUdtType(npgsqlLineType);
_instance = new NpgsqlProviderAdapter(
typeMapper,
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
dbType,
mappingSchema,
npgsqlDateType,
npgsqlPointType,
npgsqlLSegType,
npgsqlBoxType,
npgsqlCircleType,
npgsqlPathType,
npgsqlPolygonType,
npgsqlLineType,
npgsqlInetType,
npgsqlTimeSpanType,
npgsqlDateTimeType,
npgsqlRangeTType,
typeMapper.BuildWrappedFactory((string connectionString) => new NpgsqlConnection(connectionString)),
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
npgsqlBinaryImporterType.GetMethod("Complete") != null,
npgsqlBinaryImporterType,
beginBinaryImport);
void AddUdtType(Type type)
{
if (!type.IsValueType)
{
mappingSchema.AddScalarType(type, null, true, DataType.Udt);
}
else
{
mappingSchema.AddScalarType(type, DataType.Udt);
mappingSchema.AddScalarType(type.AsNullable(), null, true, DataType.Udt);
}
}
}
}
return(_instance);
}
public static Expression SkipMethodChain(this Expression expr, MappingSchema mappingSchema)
{
var result = Sql.ExtensionAttribute.ExcludeExtensionChain(mappingSchema, expr);
return(result);
}
static Expression GetMultipleQueryExpression(IBuildContext context, MappingSchema mappingSchema, Expression expression, HashSet <ParameterExpression> parameters)
{
if (!Common.Configuration.Linq.AllowMultipleQuery)
{
throw new LinqException("Multiple queries are not allowed. Set the 'LinqToDB.Common.Configuration.Linq.AllowMultipleQuery' flag to 'true' to allow multiple queries.");
}
expression.Visit(e =>
{
if (e.NodeType == ExpressionType.Lambda)
{
foreach (var p in ((LambdaExpression)e).Parameters)
{
parameters.Add(p);
}
}
});
// Convert associations.
//
return(expression.Transform(e =>
{
switch (e.NodeType)
{
case ExpressionType.MemberAccess:
{
var root = e.GetRootObject(mappingSchema);
if (root != null &&
root.NodeType == ExpressionType.Parameter &&
!parameters.Contains((ParameterExpression)root))
{
var res = context.IsExpression(e, 0, RequestFor.Association);
if (res.Result)
{
var table = (TableBuilder.AssociatedTableContext)res.Context;
if (table.IsList)
{
var ttype = typeof(Table <>).MakeGenericType(table.ObjectType);
var tbl = Activator.CreateInstance(ttype, context.Builder.DataContext);
var method = e == expression ?
MemberHelper.MethodOf <IEnumerable <bool> >(n => n.Where(a => a)).GetGenericMethodDefinition().MakeGenericMethod(table.ObjectType) :
_whereMethodInfo.MakeGenericMethod(e.Type, table.ObjectType, ttype);
var me = (MemberExpression)e;
var op = Expression.Parameter(table.ObjectType, "t");
parameters.Add(op);
Expression ex = null;
for (var i = 0; i < table.Association.ThisKey.Length; i++)
{
var field1 = table.ParentAssociation.SqlTable.Fields[table.Association.ThisKey [i]];
var field2 = table.SqlTable.Fields[table.Association.OtherKey[i]];
var ma1 = Expression.MakeMemberAccess(op, field2.ColumnDescriptor.MemberInfo);
var ma2 = Expression.MakeMemberAccess(me.Expression, field1.ColumnDescriptor.MemberInfo);
var ee = Equal(mappingSchema, ma1, ma2);
ex = ex == null ? ee : Expression.AndAlso(ex, ee);
}
var expr = Expression.Call(null, method, Expression.Constant(tbl), Expression.Lambda(ex, op));
if (e == expression)
{
expr = Expression.Call(
MemberHelper.MethodOf <IEnumerable <int> >(n => n.ToList()).GetGenericMethodDefinition().MakeGenericMethod(table.ObjectType),
expr);
}
return expr;
}
}
}
break;
}
}
return e;
}));
}
static Expression GetFromEnum(Type @from, Type to, Expression expression, MappingSchema mappingSchema)
{
if (from.IsEnumEx())
{
var fromFields = @from.GetFieldsEx()
.Where(f => (f.Attributes & EnumField) == EnumField)
.Select(f => new EnumValues {
Field = f, Attrs = mappingSchema.GetAttributes <MapValueAttribute>(f, a => a.Configuration)
})
.ToList();
{
var toTypeFields = fromFields
.Select(f => new { f.Field, Attrs = f.Attrs
.OrderBy(a =>
{
var idx = a.Configuration == null ?
int.MaxValue :
Array.IndexOf(mappingSchema.ConfigurationList, a.Configuration);
return(idx < 0 ? int.MaxValue : idx);
})
.ThenBy(a => !a.IsDefault)
.ThenBy(a => a.Value == null)
.FirstOrDefault(a => a.Value == null || a.Value.GetType() == to) })
.ToList();
if (toTypeFields.All(f => f.Attrs != null))
{
var cases = toTypeFields.Select(f => Expression.SwitchCase(
Expression.Constant(f.Attrs.Value ?? mappingSchema.GetDefaultValue(to), to),
Expression.Constant(Enum.Parse(@from, f.Field.Name, false))));
var expr = Expression.Switch(
expression,
Expression.Convert(
Expression.Call(_defaultConverter,
Expression.Convert(expression, typeof(object)),
Expression.Constant(to)),
to),
cases.ToArray());
return(expr);
}
if (toTypeFields.Any(f => f.Attrs != null))
{
var field = toTypeFields.First(f => f.Attrs == null);
return(Expression.Convert(
Expression.Call(
_throwLinqToDBConvertException,
Expression.Constant(
"Inconsistent mapping. '{0}.{1}' does not have MapValue(<{2}>) attribute."
.Args(from.FullName, field.Field.Name, to.FullName))),
to));
}
}
if (to.IsEnumEx())
{
var toFields = to.GetFieldsEx()
.Where(f => (f.Attributes & EnumField) == EnumField)
.Select(f => new EnumValues {
Field = f, Attrs = mappingSchema.GetAttributes <MapValueAttribute>(f, a => a.Configuration)
})
.ToList();
var dic = new Dictionary <EnumValues, EnumValues>();
var cl = mappingSchema.ConfigurationList.Concat(new[] { "", null }).Select((c, i) => new { c, i }).ToArray();
foreach (var toField in toFields)
{
if (toField.Attrs == null || toField.Attrs.Length == 0)
{
return(null);
}
var toAttr = toField.Attrs.First();
toAttr = toField.Attrs.FirstOrDefault(a => a.Configuration == toAttr.Configuration && a.IsDefault) ?? toAttr;
var fromAttrs = fromFields.Where(f => f.Attrs.Any(a =>
a.Value == null ? toAttr.Value == null : a.Value.Equals(toAttr.Value))).ToList();
if (fromAttrs.Count == 0)
{
return(null);
}
if (fromAttrs.Count > 1)
{
var fattrs =
from f in fromAttrs
select new {
f,
a = f.Attrs.First(a => a.Value == null ? toAttr.Value == null : a.Value.Equals(toAttr.Value))
} into fa
from c in cl
where fa.a.Configuration == c.c
orderby c.i
select fa.f;
fromAttrs = fattrs.Take(1).ToList();
}
var prev = dic
.Where(a => a.Value.Field == fromAttrs[0].Field)
.Select(pair => new { To = pair.Key, From = pair.Value })
.FirstOrDefault();
if (prev != null)
{
return(Expression.Convert(
Expression.Call(
_throwLinqToDBConvertException,
Expression.Constant(
"Mapping ambiguity. '{0}.{1}' can be mapped to either '{2}.{3}' or '{2}.{4}'.".Args(
from.FullName, fromAttrs[0].Field.Name,
to.FullName,
prev.To.Field.Name,
toField.Field.Name))),
to));
}
dic.Add(toField, fromAttrs[0]);
}
if (dic.Count > 0)
{
var cases = dic.Select(f => Expression.SwitchCase(
Expression.Constant(Enum.Parse(@to, f.Key.Field.Name, false)),
Expression.Constant(Enum.Parse(@from, f.Value.Field.Name, false))));
var expr = Expression.Switch(
expression,
Expression.Convert(
Expression.Call(_defaultConverter,
Expression.Convert(expression, typeof(object)),
Expression.Constant(to)),
to),
cases.ToArray());
return(expr);
}
}
}
return(null);
}
public static Tuple <LambdaExpression, LambdaExpression, bool> GetConverter(MappingSchema mappingSchema, Type from, Type to)
{
if (mappingSchema == null)
{
mappingSchema = MappingSchema.Default;
}
var p = Expression.Parameter(from, "p");
var ne = null as LambdaExpression;
if (from == to)
{
return(Tuple.Create(Expression.Lambda(p, p), ne, false));
}
if (to == typeof(object))
{
return(Tuple.Create(Expression.Lambda(Expression.Convert(p, typeof(object)), p), ne, false));
}
var ex =
GetConverter(mappingSchema, p, @from, to) ??
ConvertUnderlying(mappingSchema, p, @from, @from.ToNullableUnderlying(), to, to.ToNullableUnderlying()) ??
ConvertUnderlying(mappingSchema, p, @from, @from.ToUnderlying(), to, to.ToUnderlying());
if (ex != null)
{
ne = Expression.Lambda(ex.Item1, p);
if (from.IsNullable())
{
ex = Tuple.Create(
Expression.Condition(Expression.PropertyOrField(p, "HasValue"), ex.Item1, new DefaultValueExpression(mappingSchema, to)) as Expression,
ex.Item2);
}
else if (from.IsClassEx())
{
ex = Tuple.Create(
Expression.Condition(Expression.NotEqual(p, Expression.Constant(null, from)), ex.Item1, new DefaultValueExpression(mappingSchema, to)) as Expression,
ex.Item2);
}
}
if (ex != null)
{
return(Tuple.Create(Expression.Lambda(ex.Item1, p), ne, ex.Item2));
}
if (to.IsNullable())
{
var uto = to.ToNullableUnderlying();
var defex = Expression.Call(_defaultConverter,
Expression.Convert(p, typeof(object)),
Expression.Constant(uto)) as Expression;
if (defex.Type != uto)
{
defex = Expression.Convert(defex, uto);
}
defex = GetCtor(uto, to, defex);
return(Tuple.Create(Expression.Lambda(defex, p), ne, false));
}
else
{
var defex = Expression.Call(_defaultConverter,
Expression.Convert(p, typeof(object)),
Expression.Constant(to)) as Expression;
if (defex.Type != to)
{
defex = Expression.Convert(defex, to);
}
return(Tuple.Create(Expression.Lambda(defex, p), ne, false));
}
}
protected override void OnConnectionTypeCreated(Type connectionType)
{
var typesNamespace = OracleTools.AssemblyName + ".Types.";
_oracleBFile = connectionType.Assembly.GetType(typesNamespace + "OracleBFile", true);
_oracleBinary = connectionType.Assembly.GetType(typesNamespace + "OracleBinary", true);
_oracleBlob = connectionType.Assembly.GetType(typesNamespace + "OracleBlob", true);
_oracleClob = connectionType.Assembly.GetType(typesNamespace + "OracleClob", true);
_oracleDate = connectionType.Assembly.GetType(typesNamespace + "OracleDate", true);
_oracleDecimal = connectionType.Assembly.GetType(typesNamespace + "OracleDecimal", true);
_oracleIntervalDS = connectionType.Assembly.GetType(typesNamespace + "OracleIntervalDS", true);
_oracleIntervalYM = connectionType.Assembly.GetType(typesNamespace + "OracleIntervalYM", true);
_oracleRefCursor = connectionType.Assembly.GetType(typesNamespace + "OracleRefCursor", true);
_oracleString = connectionType.Assembly.GetType(typesNamespace + "OracleString", true);
_oracleTimeStamp = connectionType.Assembly.GetType(typesNamespace + "OracleTimeStamp", true);
_oracleTimeStampLTZ = connectionType.Assembly.GetType(typesNamespace + "OracleTimeStampLTZ", true);
_oracleTimeStampTZ = connectionType.Assembly.GetType(typesNamespace + "OracleTimeStampTZ", true);
_oracleRef = connectionType.Assembly.GetType(typesNamespace + "OracleRef", false);
_oracleXmlType = connectionType.Assembly.GetType(typesNamespace + "OracleXmlType", false);
_oracleXmlStream = connectionType.Assembly.GetType(typesNamespace + "OracleXmlStream", false);
SetProviderField(_oracleBFile, _oracleBFile, "GetOracleBFile");
SetProviderField(_oracleBinary, _oracleBinary, "GetOracleBinary");
SetProviderField(_oracleBlob, _oracleBlob, "GetOracleBlob");
SetProviderField(_oracleClob, _oracleClob, "GetOracleClob");
SetProviderField(_oracleDate, _oracleDate, "GetOracleDate");
SetProviderField(_oracleDecimal, _oracleDecimal, "GetOracleDecimal");
SetProviderField(_oracleIntervalDS, _oracleIntervalDS, "GetOracleIntervalDS");
SetProviderField(_oracleIntervalYM, _oracleIntervalYM, "GetOracleIntervalYM");
SetProviderField(_oracleString, _oracleString, "GetOracleString");
SetProviderField(_oracleTimeStamp, _oracleTimeStamp, "GetOracleTimeStamp");
SetProviderField(_oracleTimeStampLTZ, _oracleTimeStampLTZ, "GetOracleTimeStampLTZ");
SetProviderField(_oracleTimeStampTZ, _oracleTimeStampTZ, "GetOracleTimeStampTZ");
try
{
if (_oracleRef != null)
{
SetProviderField(_oracleRef, _oracleRef, "GetOracleRef");
}
}
catch
{
}
try
{
if (_oracleXmlType != null)
{
SetProviderField(_oracleXmlType, _oracleXmlType, "GetOracleXmlType");
}
}
catch
{
}
var dataReaderParameter = Expression.Parameter(DataReaderType, "r");
var indexParameter = Expression.Parameter(typeof(int), "i");
{
// static DateTimeOffset GetOracleTimeStampTZ(OracleDataReader rd, int idx)
// {
// var tstz = rd.GetOracleTimeStampTZ(idx);
// return new DateTimeOffset(
// tstz.Year, tstz.Month, tstz.Day,
// tstz.Hour, tstz.Minute, tstz.Second, (int)tstz.Millisecond,
// TimeSpan.Parse(tstz.TimeZone.TrimStart('+')));
// }
var tstz = Expression.Parameter(_oracleTimeStampTZ, "tstz");
ReaderExpressions[new ReaderInfo {
ToType = typeof(DateTimeOffset), ProviderFieldType = _oracleTimeStampTZ
}] =
Expression.Lambda(
Expression.Block(
new[] { tstz },
new Expression[]
{
Expression.Assign(tstz, Expression.Call(dataReaderParameter, "GetOracleTimeStampTZ", null, indexParameter)),
Expression.New(
MemberHelper.ConstructorOf(() => new DateTimeOffset(0, 0, 0, 0, 0, 0, 0, new TimeSpan())),
Expression.PropertyOrField(tstz, "Year"),
Expression.PropertyOrField(tstz, "Month"),
Expression.PropertyOrField(tstz, "Day"),
Expression.PropertyOrField(tstz, "Hour"),
Expression.PropertyOrField(tstz, "Minute"),
Expression.PropertyOrField(tstz, "Second"),
Expression.Convert(Expression.PropertyOrField(tstz, "Millisecond"), typeof(int)),
Expression.Call(
MemberHelper.MethodOf(() => TimeSpan.Parse("")),
Expression.Call(
Expression.PropertyOrField(tstz, "TimeZone"),
MemberHelper.MethodOf(() => "".TrimStart(' ')),
Expression.NewArrayInit(typeof(char), Expression.Constant('+'))))
)
}),
dataReaderParameter,
indexParameter);
}
{
// static DateTimeOffset GetOracleTimeStampLTZ(OracleDataReader rd, int idx)
// {
// var tstz = rd.GetOracleTimeStampLTZ(idx).ToOracleTimeStampTZ();
// return new DateTimeOffset(
// tstz.Year, tstz.Month, tstz.Day,
// tstz.Hour, tstz.Minute, tstz.Second, (int)tstz.Millisecond,
// TimeSpan.Parse(tstz.TimeZone.TrimStart('+')));
// }
var tstz = Expression.Parameter(_oracleTimeStampTZ, "tstz");
ReaderExpressions[new ReaderInfo {
ToType = typeof(DateTimeOffset), ProviderFieldType = _oracleTimeStampLTZ
}] =
Expression.Lambda(
Expression.Block(
new[] { tstz },
new Expression[]
{
Expression.Assign(
tstz,
Expression.Call(
Expression.Call(dataReaderParameter, "GetOracleTimeStampLTZ", null, indexParameter),
"ToOracleTimeStampTZ",
null,
null)),
Expression.New(
MemberHelper.ConstructorOf(() => new DateTimeOffset(0, 0, 0, 0, 0, 0, 0, new TimeSpan())),
Expression.PropertyOrField(tstz, "Year"),
Expression.PropertyOrField(tstz, "Month"),
Expression.PropertyOrField(tstz, "Day"),
Expression.PropertyOrField(tstz, "Hour"),
Expression.PropertyOrField(tstz, "Minute"),
Expression.PropertyOrField(tstz, "Second"),
Expression.Convert(Expression.PropertyOrField(tstz, "Millisecond"), typeof(int)),
Expression.Call(
MemberHelper.MethodOf(() => TimeSpan.Parse("")),
Expression.Call(
Expression.PropertyOrField(tstz, "TimeZone"),
MemberHelper.MethodOf(() => "".TrimStart(' ')),
Expression.NewArrayInit(typeof(char), Expression.Constant('+'))))
)
}),
dataReaderParameter,
indexParameter);
}
{
// ((OracleCommand)dataConnection.Command).BindByName = true;
var p = Expression.Parameter(typeof(DataConnection), "dataConnection");
_setBindByName =
Expression.Lambda <Action <DataConnection> >(
Expression.Assign(
Expression.PropertyOrField(
Expression.Convert(
Expression.PropertyOrField(p, "Command"),
connectionType.Assembly.GetType(OracleTools.AssemblyName + ".Client.OracleCommand", true)),
"BindByName"),
Expression.Constant(true)),
p
).Compile();
}
{
// value = new OracleTimeStampTZ(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, zone);
var dto = Expression.Parameter(typeof(DateTimeOffset), "dto");
var zone = Expression.Parameter(typeof(string), "zone");
_createOracleTimeStampTZ =
Expression.Lambda <Func <DateTimeOffset, string, object> >(
Expression.Convert(
Expression.New(
_oracleTimeStampTZ.GetConstructor(new[]
{
typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(string)
}),
Expression.PropertyOrField(dto, "Year"),
Expression.PropertyOrField(dto, "Month"),
Expression.PropertyOrField(dto, "Day"),
Expression.PropertyOrField(dto, "Hour"),
Expression.PropertyOrField(dto, "Minute"),
Expression.PropertyOrField(dto, "Second"),
Expression.PropertyOrField(dto, "Millisecond"),
zone),
typeof(object)),
dto,
zone
).Compile();
}
_setSingle = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "BinaryFloat");
_setDouble = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "BinaryDouble");
_setText = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Clob");
_setNText = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "NClob");
_setImage = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Blob");
_setBinary = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Blob");
_setVarBinary = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Blob");
_setDate = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Date");
_setSmallDateTime = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Date");
_setDateTime2 = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "TimeStamp");
_setDateTimeOffset = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "TimeStampTZ");
_setGuid = GetSetParameter(connectionType, "OracleParameter", "OracleDbType", "OracleDbType", "Raw");
MappingSchema.AddScalarType(_oracleBFile, GetNullValue(_oracleBFile), true, DataType.VarChar); // ?
MappingSchema.AddScalarType(_oracleBinary, GetNullValue(_oracleBinary), true, DataType.VarBinary);
MappingSchema.AddScalarType(_oracleBlob, GetNullValue(_oracleBlob), true, DataType.Blob); // ?
MappingSchema.AddScalarType(_oracleClob, GetNullValue(_oracleClob), true, DataType.NText);
MappingSchema.AddScalarType(_oracleDate, GetNullValue(_oracleDate), true, DataType.DateTime);
MappingSchema.AddScalarType(_oracleDecimal, GetNullValue(_oracleDecimal), true, DataType.Decimal);
MappingSchema.AddScalarType(_oracleIntervalDS, GetNullValue(_oracleIntervalDS), true, DataType.Time); // ?
MappingSchema.AddScalarType(_oracleIntervalYM, GetNullValue(_oracleIntervalYM), true, DataType.Date); // ?
MappingSchema.AddScalarType(_oracleRefCursor, GetNullValue(_oracleRefCursor), true, DataType.Binary); // ?
MappingSchema.AddScalarType(_oracleString, GetNullValue(_oracleString), true, DataType.NVarChar);
MappingSchema.AddScalarType(_oracleTimeStamp, GetNullValue(_oracleTimeStamp), true, DataType.DateTime2);
MappingSchema.AddScalarType(_oracleTimeStampLTZ, GetNullValue(_oracleTimeStampLTZ), true, DataType.DateTimeOffset);
MappingSchema.AddScalarType(_oracleTimeStampTZ, GetNullValue(_oracleTimeStampTZ), true, DataType.DateTimeOffset);
if (_oracleRef != null)
{
MappingSchema.AddScalarType(_oracleRef, GetNullValue(_oracleRef), true, DataType.Binary); // ?
}
if (_oracleXmlType != null)
{
MappingSchema.AddScalarType(_oracleXmlType, GetNullValue(_oracleXmlType), true, DataType.Xml);
}
if (_oracleXmlStream != null)
{
MappingSchema.AddScalarType(_oracleXmlStream, GetNullValue(_oracleXmlStream), true, DataType.Xml); // ?
}
}
public virtual ISqlExpression GetExpression(MappingSchema mapping, SelectQuery query, Expression expression, Func <Expression, ISqlExpression> converter)
{
return(null);
}
public PostgreSQLSqlBuilder(IDataProvider?provider, MappingSchema mappingSchema, ISqlOptimizer sqlOptimizer, SqlProviderFlags sqlProviderFlags)
: base(provider, mappingSchema, sqlOptimizer, sqlProviderFlags)
{
}
public Expression GetReaderExpression(MappingSchema mappingSchema, IDataReader reader, int idx, Expression readerExpression, Type toType)
{
return(_context.GetReaderExpression(mappingSchema, reader, idx, readerExpression, toType));
}
Expression IDataContext.GetReaderExpression(MappingSchema mappingSchema, IDataReader reader, int idx, Expression readerExpression, Type toType)
{
return(DataProvider.GetReaderExpression(mappingSchema, reader, idx, readerExpression, toType));
}
public SqlTable([JetBrains.Annotations.NotNull] MappingSchema mappingSchema, Type objectType) : this()
{
if (mappingSchema == null)
{
throw new ArgumentNullException("mappingSchema");
}
var ed = mappingSchema.GetEntityDescriptor(objectType);
Database = ed.DatabaseName;
Owner = ed.SchemaName;
Name = ed.TableName;
ObjectType = objectType;
PhysicalName = Name;
foreach (var column in ed.Columns)
{
var field = new SqlField
{
SystemType = column.MemberType,
Name = column.MemberName,
PhysicalName = column.ColumnName,
CanBeNull = column.CanBeNull,
IsPrimaryKey = column.IsPrimaryKey,
PrimaryKeyOrder = column.PrimaryKeyOrder,
IsIdentity = column.IsIdentity,
IsInsertable = !column.SkipOnInsert,
IsUpdatable = !column.SkipOnUpdate,
DataType = column.DataType,
DbType = column.DbType,
Length = column.Length,
Precision = column.Precision,
Scale = column.Scale,
CreateFormat = column.CreateFormat,
ColumnDescriptor = column,
};
Add(field);
if (field.DataType == DataType.Undefined)
{
var dataType = mappingSchema.GetDataType(field.SystemType);
if (dataType.DataType == DataType.Undefined)
{
var canBeNull = field.CanBeNull;
dataType = mappingSchema.GetUnderlyingDataType(field.SystemType, ref canBeNull);
field.CanBeNull = canBeNull;
}
field.DataType = dataType.DataType;
if (field.Length == null)
{
field.Length = dataType.Length;
}
if (field.Precision == null)
{
field.Precision = dataType.Precision;
}
if (field.Scale == null)
{
field.Scale = dataType.Scale;
}
}
}
var identityField = GetIdentityField();
if (identityField != null)
{
var cd = ed[identityField.Name];
SequenceAttributes = mappingSchema.GetAttributes <SequenceNameAttribute>(
cd.MemberAccessor.TypeAccessor.Type,
cd.MemberAccessor.MemberInfo, a => a.Configuration);
}
}
public SqlTable(MappingSchema mappingSchema)
: base(mappingSchema, typeof(T))
{
}
public override ISqlBuilder CreateSqlBuilder(MappingSchema mappingSchema)
{
return(new SapHanaOdbcSqlBuilder(GetSqlOptimizer(), SqlProviderFlags, mappingSchema.ValueToSqlConverter));
}
protected override void OnConnectionTypeCreated(Type connectionType)
{
DB2Types.ConnectionType = connectionType;
DB2Types.DB2Int64.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Int64", true);
DB2Types.DB2Int32.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Int32", true);
DB2Types.DB2Int16.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Int16", true);
DB2Types.DB2Decimal.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Decimal", true);
DB2Types.DB2DecimalFloat.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2DecimalFloat", true);
DB2Types.DB2Real.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Real", true);
DB2Types.DB2Real370.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Real370", true);
DB2Types.DB2Double.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Double", true);
DB2Types.DB2String.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2String", true);
DB2Types.DB2Clob.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Clob", true);
DB2Types.DB2Binary.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Binary", true);
DB2Types.DB2Blob.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Blob", true);
DB2Types.DB2Date.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Date", true);
DB2Types.DB2Time.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Time", true);
DB2Types.DB2TimeStamp.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2TimeStamp", true);
DB2Types.DB2Xml = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2Xml", true);
DB2Types.DB2RowId.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2RowId", true);
DB2Types.DB2DateTime.Type = connectionType.AssemblyEx().GetType("IBM.Data.DB2Types.DB2DateTime", false);
SetProviderField(DB2Types.DB2Int64, typeof(Int64), "GetDB2Int64");
SetProviderField(DB2Types.DB2Int32, typeof(Int32), "GetDB2Int32");
SetProviderField(DB2Types.DB2Int16, typeof(Int16), "GetDB2Int16");
SetProviderField(DB2Types.DB2Decimal, typeof(Decimal), "GetDB2Decimal");
SetProviderField(DB2Types.DB2DecimalFloat, typeof(Decimal), "GetDB2DecimalFloat");
SetProviderField(DB2Types.DB2Real, typeof(Single), "GetDB2Real");
SetProviderField(DB2Types.DB2Real370, typeof(Single), "GetDB2Real370");
SetProviderField(DB2Types.DB2Double, typeof(Double), "GetDB2Double");
SetProviderField(DB2Types.DB2String, typeof(String), "GetDB2String");
SetProviderField(DB2Types.DB2Clob, typeof(String), "GetDB2Clob");
SetProviderField(DB2Types.DB2Binary, typeof(byte[]), "GetDB2Binary");
SetProviderField(DB2Types.DB2Blob, typeof(byte[]), "GetDB2Blob");
SetProviderField(DB2Types.DB2Date, typeof(DateTime), "GetDB2Date");
SetProviderField(DB2Types.DB2Time, typeof(TimeSpan), "GetDB2Time");
SetProviderField(DB2Types.DB2TimeStamp, typeof(DateTime), "GetDB2TimeStamp");
SetProviderField(DB2Types.DB2Xml, typeof(string), "GetDB2Xml");
SetProviderField(DB2Types.DB2RowId, typeof(byte[]), "GetDB2RowId");
MappingSchema.AddScalarType(DB2Types.DB2Int64, GetNullValue(DB2Types.DB2Int64), true, DataType.Int64);
MappingSchema.AddScalarType(DB2Types.DB2Int32, GetNullValue(DB2Types.DB2Int32), true, DataType.Int32);
MappingSchema.AddScalarType(DB2Types.DB2Int16, GetNullValue(DB2Types.DB2Int16), true, DataType.Int16);
MappingSchema.AddScalarType(DB2Types.DB2Decimal, GetNullValue(DB2Types.DB2Decimal), true, DataType.Decimal);
MappingSchema.AddScalarType(DB2Types.DB2DecimalFloat, GetNullValue(DB2Types.DB2DecimalFloat), true, DataType.Decimal);
MappingSchema.AddScalarType(DB2Types.DB2Real, GetNullValue(DB2Types.DB2Real), true, DataType.Single);
MappingSchema.AddScalarType(DB2Types.DB2Real370, GetNullValue(DB2Types.DB2Real370), true, DataType.Single);
MappingSchema.AddScalarType(DB2Types.DB2Double, GetNullValue(DB2Types.DB2Double), true, DataType.Double);
MappingSchema.AddScalarType(DB2Types.DB2String, GetNullValue(DB2Types.DB2String), true, DataType.NVarChar);
MappingSchema.AddScalarType(DB2Types.DB2Clob, GetNullValue(DB2Types.DB2Clob), true, DataType.NText);
MappingSchema.AddScalarType(DB2Types.DB2Binary, GetNullValue(DB2Types.DB2Binary), true, DataType.VarBinary);
MappingSchema.AddScalarType(DB2Types.DB2Blob, GetNullValue(DB2Types.DB2Blob), true, DataType.Blob);
MappingSchema.AddScalarType(DB2Types.DB2Date, GetNullValue(DB2Types.DB2Date), true, DataType.Date);
MappingSchema.AddScalarType(DB2Types.DB2Time, GetNullValue(DB2Types.DB2Time), true, DataType.Time);
MappingSchema.AddScalarType(DB2Types.DB2TimeStamp, GetNullValue(DB2Types.DB2TimeStamp), true, DataType.DateTime2);
MappingSchema.AddScalarType(DB2Types.DB2RowId, GetNullValue(DB2Types.DB2RowId), true, DataType.VarBinary);
MappingSchema.AddScalarType(DB2Types.DB2Xml, DB2Tools.IsCore ? null : GetNullValue(DB2Types.DB2Xml), true, DataType.Xml);
_setBlob = GetSetParameter(connectionType, "DB2Parameter", "DB2Type", "DB2Type", "Blob");
if (DB2Types.DB2DateTime.IsSupported)
{
SetProviderField(DB2Types.DB2DateTime, typeof(DateTime), "GetDB2DateTime");
MappingSchema.AddScalarType(DB2Types.DB2DateTime, GetNullValue(DB2Types.DB2DateTime), true, DataType.DateTime);
}
if (DataConnection.TraceSwitch.TraceInfo)
{
DataConnection.WriteTraceLine(
DataReaderType.AssemblyEx().FullName,
DataConnection.TraceSwitch.DisplayName);
DataConnection.WriteTraceLine(
DB2Types.DB2DateTime.IsSupported ? "DB2DateTime is supported." : "DB2DateTime is not supported.",
DataConnection.TraceSwitch.DisplayName);
}
DB2Tools.Initialized();
}
public SqlServer2012SqlBuilder(SqlServerDataProvider?provider, MappingSchema mappingSchema, ISqlOptimizer sqlOptimizer, SqlProviderFlags sqlProviderFlags)
: base(provider, mappingSchema, sqlOptimizer, sqlProviderFlags)
{
}
private static OracleProviderAdapter CreateAdapter(string assemblyName, string clientNamespace, string typesNamespace, string?factoryName)
{
var assembly = Common.Tools.TryLoadAssembly(assemblyName, factoryName);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {assemblyName}");
}
var connectionType = assembly.GetType($"{clientNamespace}.OracleConnection", true) !;
var parameterType = assembly.GetType($"{clientNamespace}.OracleParameter", true) !;
var dataReaderType = assembly.GetType($"{clientNamespace}.OracleDataReader", true) !;
var transactionType = assembly.GetType($"{clientNamespace}.OracleTransaction", true) !;
var dbType = assembly.GetType($"{clientNamespace}.OracleDbType", true) !;
var commandType = assembly.GetType($"{clientNamespace}.OracleCommand", true) !;
var mappingSchema = new MappingSchema();
// do not set default conversion for BFile as it could be converted to file name, byte[], Stream and we don't know what user needs
var oracleBFileType = loadType("OracleBFile", DataType.BFile, skipConvertExpression: true) !;
var oracleBinaryType = loadType("OracleBinary", DataType.VarBinary) !;
var oracleBlobType = loadType("OracleBlob", DataType.Blob) !;
var oracleClobType = loadType("OracleClob", DataType.NText) !;
var oracleDateType = loadType("OracleDate", DataType.DateTime) !;
var oracleDecimalType = loadType("OracleDecimal", DataType.Decimal) !;
var oracleIntervalDSType = loadType("OracleIntervalDS", DataType.Time) !;
var oracleIntervalYMType = loadType("OracleIntervalYM", DataType.Date) !;
var oracleStringType = loadType("OracleString", DataType.NVarChar) !;
var oracleTimeStampType = loadType("OracleTimeStamp", DataType.DateTime2) !;
var oracleTimeStampLTZType = loadType("OracleTimeStampLTZ", DataType.DateTimeOffset) !;
var oracleTimeStampTZType = loadType("OracleTimeStampTZ", DataType.DateTimeOffset) !;
var oracleXmlTypeType = loadType("OracleXmlType", DataType.Xml) !;
var oracleXmlStreamType = loadType("OracleXmlStream", DataType.Xml, true, false) !;
var oracleRefCursorType = loadType("OracleRefCursor", DataType.Binary, hasValue: false) !;
var oracleRefType = loadType("OracleRef", DataType.Binary, true);
BulkCopyAdapter?bulkCopy = null;
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <OracleConnection>(connectionType);
typeMapper.RegisterTypeWrapper <OracleParameter>(parameterType);
typeMapper.RegisterTypeWrapper <OracleDbType>(dbType);
typeMapper.RegisterTypeWrapper <OracleCommand>(commandType);
typeMapper.RegisterTypeWrapper <OracleDataReader>(dataReaderType);
typeMapper.RegisterTypeWrapper <OracleTimeStampTZ>(oracleTimeStampTZType);
typeMapper.RegisterTypeWrapper <OracleTimeStampLTZ>(oracleTimeStampLTZType);
typeMapper.RegisterTypeWrapper <OracleDecimal>(oracleDecimalType);
var bulkCopyType = assembly.GetType($"{clientNamespace}.OracleBulkCopy", false);
if (bulkCopyType != null)
{
var bulkCopyOptionsType = assembly.GetType($"{clientNamespace}.OracleBulkCopyOptions", true) !;
var bulkRowsCopiedEventHandlerType = assembly.GetType($"{clientNamespace}.OracleRowsCopiedEventHandler", true) !;
var bulkCopyColumnMappingType = assembly.GetType($"{clientNamespace}.OracleBulkCopyColumnMapping", true) !;
var bulkCopyColumnMappingCollectionType = assembly.GetType($"{clientNamespace}.OracleBulkCopyColumnMappingCollection", true) !;
var rowsCopiedEventArgsType = assembly.GetType($"{clientNamespace}.OracleRowsCopiedEventArgs", true) !;
// bulk copy types
typeMapper.RegisterTypeWrapper <OracleBulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <OracleRowsCopiedEventHandler>(bulkRowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollectionType);
typeMapper.RegisterTypeWrapper <OracleRowsCopiedEventArgs>(rowsCopiedEventArgsType);
typeMapper.FinalizeMappings();
bulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((IDbConnection connection, OracleBulkCopyOptions options) => new OracleBulkCopy((OracleConnection)connection, options)),
typeMapper.BuildWrappedFactory((int source, string destination) => new OracleBulkCopyColumnMapping(source, destination)));
}
else
{
typeMapper.FinalizeMappings();
}
var paramMapper = typeMapper.Type <OracleParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.OracleDbType);
var connectionMapper = typeMapper.Type <OracleConnection>();
var commandMapper = typeMapper.Type <OracleCommand>();
// data reader expressions
// rd.GetOracleTimeStampTZ(i) => DateTimeOffset
var generator = new ExpressionGenerator(typeMapper);
var rdParam = Expression.Parameter(typeof(IDataReader), "rd");
var indexParam = Expression.Parameter(typeof(int), "i");
var tstzExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleTimeStampTZ(i), rdParam, indexParam);
var tstzVariable = generator.AssignToVariable(tstzExpr, "tstz");
var expr = generator.MapExpression((OracleTimeStampTZ tstz) => new DateTimeOffset(
tstz.Year, tstz.Month, tstz.Day,
tstz.Hour, tstz.Minute, tstz.Second,
tstz.GetTimeZoneOffset()).AddTicks(tstz.Nanosecond / NanosecondsPerTick), tstzVariable);
generator.AddExpression(expr);
var body = generator.Build();
var readDateTimeOffsetFromOracleTimeStampTZ = (Expression <Func <IDataReader, int, DateTimeOffset> >)Expression.Lambda(body, rdParam, indexParam);
// rd.GetOracleTimeStampLTZ(i) => DateTimeOffset
generator = new ExpressionGenerator(typeMapper);
tstzExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleTimeStampLTZ(i).ToOracleTimeStampTZ(), rdParam, indexParam);
tstzVariable = generator.AssignToVariable(tstzExpr, "tstz");
expr = generator.MapExpression((OracleTimeStampTZ tstz) => new DateTimeOffset(
tstz.Year, tstz.Month, tstz.Day,
tstz.Hour, tstz.Minute, tstz.Second,
tstz.GetTimeZoneOffset()).AddTicks(tstz.Nanosecond / NanosecondsPerTick), tstzVariable);
generator.AddExpression(expr);
body = generator.Build();
var readDateTimeOffsetFromOracleTimeStampLTZ = (Expression <Func <IDataReader, int, DateTimeOffset> >)Expression.Lambda(body, rdParam, indexParam);
// rd.GetOracleDecimal(i) => decimal
generator = new ExpressionGenerator(typeMapper);
var decExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleDecimal(i), rdParam, indexParam);
var oracleDecimalVar = generator.AssignToVariable(decExpr, "dec");
var precision = generator.AssignToVariable(Expression.Constant(29), "precision");
var decimalVar = generator.AddVariable(Expression.Parameter(typeof(decimal), "dec"));
var label = Expression.Label(typeof(decimal));
generator.AddExpression(
Expression.Loop(
Expression.TryCatch(
Expression.Block(
Expression.Assign(oracleDecimalVar, generator.MapExpression((OracleDecimal d, int p) => OracleDecimal.SetPrecision(d, p), oracleDecimalVar, precision)),
Expression.Assign(decimalVar, Expression.Convert(oracleDecimalVar, typeof(decimal))),
Expression.Break(label, decimalVar)),
Expression.Catch(
typeof(OverflowException),
Expression.Block(
Expression.IfThen(
Expression.LessThanOrEqual(Expression.SubtractAssign(precision, Expression.Constant(1)), Expression.Constant(26)),
Expression.Rethrow())))),
label));
body = generator.Build();
var readOracleDecimalToDecimalAdv = (Expression <Func <IDataReader, int, decimal> >)Expression.Lambda(body, rdParam, indexParam);
// workaround for mapper issue with complex reader expressions handling
// https://github.com/linq2db/linq2db/issues/2032
var compiledReader = readOracleDecimalToDecimalAdv.Compile();
readOracleDecimalToDecimalAdv = (Expression <Func <IDataReader, int, decimal> >)Expression.Lambda(
Expression.Invoke(Expression.Constant(compiledReader), rdParam, indexParam),
rdParam,
indexParam);
var readOracleDecimalToInt = (Expression <Func <IDataReader, int, int> >)typeMapper.MapLambda <IDataReader, int, int>((rd, i) => (int)(decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
var readOracleDecimalToLong = (Expression <Func <IDataReader, int, long> >)typeMapper.MapLambda <IDataReader, int, long>((rd, i) => (long)(decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
var readOracleDecimalToDecimal = (Expression <Func <IDataReader, int, decimal> >)typeMapper.MapLambda <IDataReader, int, decimal>((rd, i) => (decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
return(new OracleProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
mappingSchema,
oracleBFileType,
oracleBinaryType,
oracleBlobType,
oracleClobType,
oracleDateType,
oracleDecimalType,
oracleIntervalDSType,
oracleIntervalYMType,
oracleStringType,
oracleTimeStampType,
oracleTimeStampLTZType,
oracleTimeStampTZType,
oracleXmlTypeType,
oracleXmlStreamType,
oracleRefCursorType,
oracleRefType,
typeMapper.BuildWrappedFactory((string connectionString) => new OracleConnection(connectionString)),
typesNamespace,
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
connectionMapper.Member(c => c.HostName).BuildGetter <IDbConnection>(),
connectionMapper.Member(c => c.DatabaseName).BuildGetter <IDbConnection>(),
commandMapper.Member(p => p.BindByName).BuildSetter <IDbCommand>(),
commandMapper.Member(p => p.ArrayBindCount).BuildSetter <IDbCommand>(),
commandMapper.Member(p => p.InitialLONGFetchSize).BuildSetter <IDbCommand>(),
typeMapper.BuildFactory((DateTimeOffset dto, string offset) => new OracleTimeStampTZ(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, GetDateTimeOffsetNanoseconds(dto), offset)),
readDateTimeOffsetFromOracleTimeStampTZ,
readDateTimeOffsetFromOracleTimeStampLTZ,
readOracleDecimalToDecimalAdv,
readOracleDecimalToInt,
readOracleDecimalToLong,
readOracleDecimalToDecimal,
bulkCopy));
Type?loadType(string typeName, DataType dataType, bool optional = false, bool hasNull = true, bool hasValue = true, bool skipConvertExpression = false)
{
var type = assembly !.GetType($"{typesNamespace}.{typeName}", !optional);
if (type == null)
{
return(null);
}
if (hasNull)
{
// if native provider fails here, check that you have ODAC installed properly
var getNullValue = Expression.Lambda <Func <object> >(Expression.Convert(ExpressionHelper.Field(type, "Null"), typeof(object))).Compile();
mappingSchema.AddScalarType(type, getNullValue(), true, dataType);
}
else
{
mappingSchema.AddScalarType(type, null, true, dataType);
}
if (skipConvertExpression)
{
return(type);
}
// conversion from provider-specific type
var valueParam = Expression.Parameter(type);
Expression memberExpression;
if (!hasValue)
{
memberExpression = valueParam;
}
else
{
memberExpression = ExpressionHelper.Property(valueParam, "Value");
}
var condition = Expression.Condition(
Expression.Equal(valueParam, ExpressionHelper.Field(type, "Null")),
Expression.Constant(null, typeof(object)),
Expression.Convert(memberExpression, typeof(object)));
var convertExpression = Expression.Lambda(condition, valueParam);
mappingSchema.SetConvertExpression(type, typeof(object), convertExpression);
return(type);
}
}
public static bool IsCte(this MethodCallExpression method, MappingSchema mappingSchema)
{
return(method.IsQueryable("AsCte", "GetCte"));
}
TransformInfo TransformExpression(IBuildContext context, Expression expr, bool enforceServerSide)
{
if (_skippedExpressions.Contains(expr))
{
return(new TransformInfo(expr, true));
}
if (expr.Find(IsNoneSqlMember) != null)
{
return(new TransformInfo(expr));
}
switch (expr.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
{
if (expr.Type == typeof(object))
{
break;
}
var cex = (UnaryExpression)expr;
_convertedExpressions.Add(cex.Operand, cex);
var nex = BuildExpression(context, cex.Operand, enforceServerSide);
if (nex.Type != cex.Type)
{
nex = cex.Update(nex);
}
var ret = new TransformInfo(nex, true);
_convertedExpressions.Remove(cex.Operand);
return(ret);
}
case ExpressionType.MemberAccess:
{
if (IsServerSideOnly(expr) || PreferServerSide(expr, enforceServerSide))
{
return(new TransformInfo(BuildSql(context, expr)));
}
var ma = (MemberExpression)expr;
var l = Expressions.ConvertMember(MappingSchema, ma.Expression == null ? null : ma.Expression.Type, ma.Member);
if (l != null)
{
// In Grouping KeyContext we have to perform calculation on server side
if (Contexts.Any(c => c is GroupByBuilder.KeyContext))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
}
if (ma.Member.IsNullableValueMember())
{
break;
}
if (ma.Member.IsNullableHasValueMember())
{
Expression e = Expression.NotEqual(
ma.Expression, Expression.Constant(null, ma.Expression.Type));
return(new TransformInfo(
BuildExpression(
context,
ma.Expression.Type.IsPrimitiveEx() ?
Expression.Call(
MemberHelper.MethodOf(() => Sql.AsSql(true)),
e) :
e, enforceServerSide),
true));
}
var ctx = GetContext(context, ma);
if (ctx != null)
{
if (ma.Type.IsGenericTypeEx() && typeof(IEnumerable <>).IsSameOrParentOf(ma.Type))
{
var res = ctx.IsExpression(ma, 0, RequestFor.Association);
if (res.Result)
{
var table = (TableBuilder.AssociatedTableContext)res.Context;
if (table.IsList)
{
var mexpr = GetMultipleQueryExpression(context, MappingSchema, ma, new HashSet <ParameterExpression>());
return(new TransformInfo(BuildExpression(context, mexpr, enforceServerSide)));
}
}
}
return(new TransformInfo(ctx.BuildExpression(ma, 0, enforceServerSide)));
}
var ex = ma.Expression;
while (ex is MemberExpression)
{
ex = ((MemberExpression)ex).Expression;
}
if (ex is MethodCallExpression)
{
var ce = (MethodCallExpression)ex;
if (IsSubQuery(context, ce))
{
if (!IsMultipleQuery(ce))
{
var info = GetSubQueryContext(context, ce);
var par = Expression.Parameter(ex.Type);
var bex = info.Context.BuildExpression(ma.Transform(e => e == ex ? par : e), 0, enforceServerSide);
if (bex != null)
{
return(new TransformInfo(bex));
}
}
}
}
ex = ma.Expression;
if (ex != null && ex.NodeType == ExpressionType.Constant)
{
// field = localVariable
//
var c = _expressionAccessors[ex];
return(new TransformInfo(Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member)));
}
break;
}
case ExpressionType.Parameter:
{
if (expr == ParametersParam)
{
break;
}
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new TransformInfo(ctx.BuildExpression(expr, 0, enforceServerSide)));
}
break;
}
case ExpressionType.Constant:
{
if (expr.Type.IsConstantable())
{
break;
}
if (_expressionAccessors.ContainsKey(expr))
{
return(new TransformInfo(Expression.Convert(_expressionAccessors[expr], expr.Type)));
}
break;
}
case ExpressionType.Coalesce:
if (expr.Type == typeof(string) && MappingSchema.GetDefaultValue(typeof(string)) != null)
{
return(new TransformInfo(BuildSql(context, expr)));
}
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Conditional:
if (CanBeTranslatedToSql(context, ConvertExpression(expr), true))
{
return(new TransformInfo(BuildSql(context, expr)));
}
break;
case ExpressionType.Call:
{
var ce = (MethodCallExpression)expr;
if (IsGroupJoinSource(context, ce))
{
foreach (var arg in ce.Arguments.Skip(1))
{
if (!_skippedExpressions.Contains(arg))
{
_skippedExpressions.Add(arg);
}
}
if (IsSubQuery(context, ce))
{
if (ce.IsQueryable())
//if (!typeof(IEnumerable).IsSameOrParentOf(expr.Type) || expr.Type == typeof(string) || expr.Type.IsArray)
{
var ctx = GetContext(context, expr);
if (ctx != null)
{
return(new TransformInfo(ctx.BuildExpression(expr, 0, enforceServerSide)));
}
}
}
break;
}
if (ce.IsAssociation(MappingSchema))
{
var ctx = GetContext(context, ce);
if (ctx == null)
{
throw new InvalidOperationException();
}
return(new TransformInfo(ctx.BuildExpression(ce, 0, enforceServerSide)));
}
if ((_buildMultipleQueryExpressions == null || !_buildMultipleQueryExpressions.Contains(ce)) && IsSubQuery(context, ce))
{
if (IsMultipleQuery(ce))
{
return(new TransformInfo(BuildMultipleQuery(context, ce, enforceServerSide)));
}
return(new TransformInfo(GetSubQueryExpression(context, ce, enforceServerSide)));
}
if (IsServerSideOnly(expr) || PreferServerSide(expr, enforceServerSide) || ce.Method.IsSqlPropertyMethodEx())
{
return(new TransformInfo(BuildSql(context, expr)));
}
}
break;
}
if (EnforceServerSide(context))
{
switch (expr.NodeType)
{
case ExpressionType.MemberInit:
case ExpressionType.New:
case ExpressionType.Convert:
break;
default:
if (CanBeCompiled(expr))
{
break;
}
return(new TransformInfo(BuildSql(context, expr)));
}
}
return(new TransformInfo(expr));
}
public MetadataInfo(MappingSchema mappingSchema)
{
_mappingSchema = mappingSchema;
LoadMetadata();
}
public static void CustomerMap(MappingSchema mappingSchema)
{
mappingSchema.GetFluentMappingBuilder().Entity <Customer>()
.HasTableName("Customers")
.Property(x => x.CustomerId)
.IsPrimaryKey()
.HasColumnName("CustomerID")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(5)
.IsNullable(false)
.Property(x => x.CompanyName)
.HasColumnName("CompanyName")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(40)
.IsNullable(false)
.Property(x => x.ContactName)
.HasColumnName("ContactName")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(30)
.IsNullable(true)
.Property(x => x.ContactTitle)
.HasColumnName("ContactTitle")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(30)
.IsNullable(true)
.Property(x => x.Address)
.HasColumnName("Address")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(60)
.IsNullable(true)
.Property(x => x.City)
.HasColumnName("City")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(15)
.IsNullable(true)
.Property(x => x.Region)
.HasColumnName("Region")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(15)
.IsNullable(true)
.Property(x => x.PostalCode)
.HasColumnName("PostalCode")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(10)
.IsNullable(true)
.Property(x => x.Country)
.HasColumnName("Country")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(15)
.IsNullable(true)
.Property(x => x.Phone)
.HasColumnName("Phone")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(24)
.IsNullable(true)
.Property(x => x.Fax)
.HasColumnName("Fax")
.HasDataType(LinqToDB.DataType.VarChar)
.HasLength(24)
.IsNullable(true)
.Property(x => x.CustomerCustomerDemos)
.IsNotColumn()
.Property(x => x.Orders)
.IsNotColumn()
.Property(x => x.LookupText)
.IsNotColumn()
;
}
static Expression GetToEnum(Type @from, Type to, Expression expression, MappingSchema mappingSchema)
{
if (to.IsEnumEx())
{
var toFields = mappingSchema.GetMapValues(to);
if (toFields == null)
{
return(null);
}
var fromTypeFields = toFields
.Select(f => new { f.OrigValue, attrs = f.MapValues.Where(a => a.Value == null || a.Value.GetType() == @from).ToList() })
.ToList();
if (fromTypeFields.All(f => f.attrs.Count != 0))
{
var cases = fromTypeFields
.Select(f => new
{
value = f.OrigValue,
attrs = f.attrs
.Where(a => a.Configuration == f.attrs[0].Configuration)
.Select(a => a.Value ?? mappingSchema.GetDefaultValue(@from))
.ToList()
})
.ToList();
var ambiguityMappings =
from c in cases
from a in c.attrs
group c by a into g
where g.Count() > 1
select g;
var ambiguityMapping = ambiguityMappings.FirstOrDefault();
if (ambiguityMapping != null)
{
var enums = ambiguityMapping.ToArray();
return(Expression.Convert(
Expression.Call(
_throwLinqToDBConvertException,
Expression.Constant(
"Mapping ambiguity. MapValue({0}) attribute is defined for both '{1}.{2}' and '{1}.{3}'."
.Args(ambiguityMapping.Key, to.FullName, enums[0].value, enums[1].value))),
to));
}
var expr = Expression.Switch(
expression,
Expression.Convert(
Expression.Call(_defaultConverter,
Expression.Convert(expression, typeof(object)),
Expression.Constant(to)),
to),
cases
.Select(f =>
Expression.SwitchCase(
Expression.Constant(f.value),
(IEnumerable <Expression>)f.attrs.Select(a => Expression.Constant(a, @from))))
.ToArray());
return(expr);
}
if (fromTypeFields.Any(f => f.attrs.Count(a => a.Value != null) != 0))
{
var field = fromTypeFields.First(f => f.attrs.Count == 0);
return(Expression.Convert(
Expression.Call(
_throwLinqToDBConvertException,
Expression.Constant(
"Inconsistent mapping. '{0}.{1}' does not have MapValue(<{2}>) attribute."
.Args(to.FullName, field.OrigValue, from.FullName))),
to));
}
}
return(null);
}
private NpgsqlProviderAdapter(
TypeMapper typeMapper,
Type connectionType,
Type dataReaderType,
Type parameterType,
Type commandType,
Type transactionType,
Type dbTypeType,
MappingSchema mappingSchema,
Type npgsqlDateType,
Type npgsqlPointType,
Type npgsqlLSegType,
Type npgsqlBoxType,
Type npgsqlCircleType,
Type npgsqlPathType,
Type npgsqlPolygonType,
Type npgsqlLineType,
Type npgsqlInetType,
Type npgsqlTimeSpanType,
Type npgsqlDateTimeType,
Type npgsqlRangeTType,
Func <string, NpgsqlConnection> connectionCreator,
Action <IDbDataParameter, NpgsqlDbType> dbTypeSetter,
Func <IDbDataParameter, NpgsqlDbType> dbTypeGetter,
bool binaryImporterHasCompleteMethod,
Type npgsqlBinaryImporterType,
Func <IDbConnection, string, NpgsqlBinaryImporter> beginBinaryImport)
{
_typeMapper = typeMapper;
ConnectionType = connectionType;
DataReaderType = dataReaderType;
ParameterType = parameterType;
CommandType = commandType;
TransactionType = transactionType;
_dbTypeType = dbTypeType;
NpgsqlDateType = npgsqlDateType;
NpgsqlPointType = npgsqlPointType;
NpgsqlLSegType = npgsqlLSegType;
NpgsqlBoxType = npgsqlBoxType;
NpgsqlCircleType = npgsqlCircleType;
NpgsqlPathType = npgsqlPathType;
NpgsqlPolygonType = npgsqlPolygonType;
NpgsqlLineType = npgsqlLineType;
NpgsqlInetType = npgsqlInetType;
NpgsqlTimeSpanType = npgsqlTimeSpanType;
NpgsqlDateTimeType = npgsqlDateTimeType;
NpgsqlRangeTType = npgsqlRangeTType;
MappingSchema = mappingSchema;
_connectionCreator = connectionCreator;
SetDbType = dbTypeSetter;
GetDbType = dbTypeGetter;
BinaryImporterHasComplete = binaryImporterHasCompleteMethod;
_npgsqlBinaryImporterType = npgsqlBinaryImporterType;
BeginBinaryImport = beginBinaryImport;
// because NpgsqlDbType enumeration changes often (compared to other providers)
// we should create lookup list of mapped fields, defined in used npgsql version
var dbTypeKnownNames = Enum.GetNames(dbTypeType);
var dbMappedDbTypeNames = Enum.GetNames(typeof(NpgsqlDbType));
foreach (var knownTypeName in from nType in dbTypeKnownNames
join mType in dbMappedDbTypeNames on nType equals mType
select nType)
{
// use setter([]) instead of Add() because enum contains duplicate fields with same values
_knownDbTypes[(NpgsqlDbType)Enum.Parse(typeof(NpgsqlDbType), knownTypeName)] = (int)Enum.Parse(dbTypeType, knownTypeName);
}
}
public static bool IsAssociation(this MethodCallExpression method, MappingSchema mappingSchema)
{
return(mappingSchema.GetAttribute <AssociationAttribute>(method.Method.DeclaringType, method.Method) != null);
}
public DataContextDecorator(IDataContext context, MappingSchema mappingSchema)
{
_context = context;
_mappingSchema = mappingSchema;
}
public Expression BuildExpression(IParseContext context, Expression expression)
{
var newExpr = expression.Convert(pi =>
{
switch (pi.NodeType)
{
case ExpressionType.MemberAccess:
{
if (IsSubQuery(context, pi))
{
return(BuildSubQuery(context, pi));
}
if (IsServerSideOnly(pi) || PreferServerSide(pi))
{
return(BuildSql(context, pi));
}
var ctx = GetContext(context, pi);
if (ctx != null)
{
return(ctx.BuildExpression(pi, 0));
}
var ma = (MemberExpression)pi;
var ex = ma.Expression;
/*
* if (query.Sources.Length > 0)
* {
* var field = query.GetBaseField(lambda, ma);
*
* if (field != null)
* {
* if (field is QueryField.Column)
* return BuildField(ma, field, converter);
*
* if (field is QuerySource.SubQuery)
* return BuildSubQuerySource(ma, (QuerySource.SubQuery)field, converter);
*
* if (field is QueryField.ExprColumn)
* {
* var col = (QueryField.ExprColumn)field;
* return BuildNewExpression(lambda, col.QuerySource, col.Expr, converter);
* }
*
* if (field is QuerySource.Table)
* return BuildTable(ma, (QuerySource.Table)field, null, converter);
*
* if (field is QueryField.SubQueryColumn)
* return BuildSubQuerySource(ma, (QueryField.SubQueryColumn)field, converter);
*
* if (field is QueryField.GroupByColumn)
* return BuildGroupBy(ma, (QueryField.GroupByColumn)field, converter);
*
* if (field is QuerySource.SubQuerySourceColumn)
* return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)field, converter);
*
* throw new InvalidOperationException();
* }
*
* //if (ex.Expr == expr.Expr && query is QuerySource.Scalar && ex.NodeType == ExpressionType.Constant)
* // return BuildField(lambda, query, ma);
* }
* else
* {
* var field = GetField(lambda, ma, query);
*
* if (field != null)
* return BuildField(ma, field, converter/*i => i/);
* }
*/
if (ex != null && ex.NodeType == ExpressionType.Constant)
{
// field = localVariable
//
var c = _expressionAccessors[ex];
return(Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member));
}
break;
}
case ExpressionType.Parameter:
{
if (pi == ParametersParam)
{
break;
}
var ctx = GetContext(context, pi);
if (ctx != null)
{
return(ctx.BuildExpression(pi, 0));
}
throw new NotImplementedException();
/*
* if (query.Lambda != null &&
* query.Lambda.MethodInfo != null &&
* query.Lambda.MethodInfo.Name == "Select" &&
* query.Lambda.Parameters.Length == 2 &&
* query.Lambda.Parameters[1] == pi)
* {
* return Expression.MakeMemberAccess(_contextParam, QueryCtx.Counter);
* }
*
* var field = query.GetBaseField(lambda, pi);
*
* if (field != null)
* {
* //Func<FieldIndex,FieldIndex> conv = i => converter(query.EnsureField(i.Field).Select(this)[0]);
*
* if (field is QuerySource.Table)
* return BuildTable(pi, (QuerySource.Table)field, null, converter);
*
* if (field is QuerySource.Scalar)
* {
* var source = (QuerySource)field;
* return BuildNewExpression(lambda, source, source.Lambda.Body, converter);
* }
*
* if (field is QuerySource.Expr)
* {
* var source = (QuerySource)field;
* return BuildQuerySourceExpr(query, source.Lambda.Body, converter);
* }
*
* if (field is QuerySource.GroupJoin)
* return BuildGroupJoin(pi, (QuerySource.GroupJoin)field, converter);
*
* if (field is QuerySource.SubQuery)
* return BuildSubQuerySource(pi, (QuerySource.SubQuery)field, converter);
*
* if (field is QuerySource.SubQuerySourceColumn)
* return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)field, converter);
*
* throw new InvalidOperationException();
* }
*
* //if (query.Lambda == null && query is QuerySource.SubQuerySourceColumn)
* //{
* // return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)query, converter);
* //}
*
* break;
*/
}
case ExpressionType.Constant:
{
if (ExpressionHelper.IsConstant(pi.Type))
{
break;
}
if (_expressionAccessors.ContainsKey(pi))
{
return(Expression.Convert(_expressionAccessors[pi], pi.Type));
}
throw new NotImplementedException();
/*
* if (query.Sources.Length == 0)
* {
* var field = GetField(lambda, pi, query);
*
* if (field != null)
* {
* var idx = field.Select(this);
* return BuildField(pi, field.GetExpressions(this)[0], idx.Select(i => converter(i).Index).ToArray());
* }
* }
*
* if (query is QuerySource.Scalar && CurrentSql.Select.Columns.Count == 0 && expr == pi)
* return BuildField(lambda, query.BaseQuery, pi, converter);
*
* if (query is QuerySource.SubQuerySourceColumn)
* return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)query, converter);
*
* return Expression.Convert(ExpressionAccessors[pi], pi.Type);
*/
}
case ExpressionType.Coalesce:
if (pi.Type == typeof(string) && MappingSchema.GetDefaultNullValue <string>() != null)
{
return(BuildSql(context, pi));
}
if (CanBeTranslatedToSql(context, pi, true))
{
return(BuildSql(context, pi));
}
break;
case ExpressionType.Conditional:
if (CanBeTranslatedToSql(context, pi, true))
{
return(BuildSql(context, pi));
}
break;
case ExpressionType.Call:
{
var ce = (MethodCallExpression)pi;
var cm = ConvertMethod(ce);
if (cm != null)
{
if (ce.Method.GetCustomAttributes(typeof(MethodExpressionAttribute), true).Length != 0)
{
return(BuildExpression(context, cm));
}
}
if (IsSubQuery(context, pi))
{
return(BuildSubQuery(context, pi));
}
if (IsServerSideOnly(pi) || PreferServerSide(pi))
{
return(BuildSql(context, pi));
}
}
break;
}
if (EnforceServerSide(context))
{
switch (pi.NodeType)
{
case ExpressionType.MemberInit:
case ExpressionType.New:
case ExpressionType.Convert:
break;
default:
if (CanBeCompiled(pi))
{
break;
}
return(BuildSql(context, pi));
}
}
return(pi);
});
return(newExpr);
}
public override ISqlBuilder CreateSqlBuilder(MappingSchema mappingSchema)
{
return(new FirebirdSqlBuilder(this, mappingSchema, GetSqlOptimizer(), SqlProviderFlags));
}
public void Issue693Test([DataSources] string context)
{
ResetPersonIdentity(context);
var ms = new MappingSchema();
ms.SetConverter <Test?, string?>((obj) =>
{
if (obj != null)
{
return(obj.ToString());
}
return(null);
});
ms.SetConverter <Test?, DataParameter>((obj) =>
{
if (obj != null)
{
return new DataParameter {
Value = obj.ToString(), DataType = DataType.NVarChar
}
}
;
return(new DataParameter {
Value = DBNull.Value
});
});
ms.SetConverter <string, Test?>((txt) =>
{
if (string.IsNullOrEmpty(txt))
{
return(null);
}
return((Test?)Enum.Parse(typeof(Test), txt, true));
});
using (var db = GetDataContext(context, ms))
using (new DeletePerson(db))
{
var obj = new Entity533
{
FirstName = "a",
MiddleName = Test.A,
LastName = "b",
Gender = Gender.Male
};
var id1 = Convert.ToInt32(db.InsertWithIdentity(obj));
var obj2 = new Entity533
{
FirstName = "c",
MiddleName = null,
LastName = "d",
Gender = Gender.Male
};
var id2 = Convert.ToInt32(db.InsertWithIdentity(obj2));
var obj3 = db.GetTable <Entity533>().First(_ => _.ID == id1);
var obj4 = db.GetTable <Entity533>().First(_ => _.ID == id2);
Assert.IsNull(obj4.MiddleName);
Assert.NotNull(obj3.MiddleName);
}
}
private OracleProviderAdapter(
Type connectionType,
Type dataReaderType,
Type parameterType,
Type commandType,
Type transactionType,
MappingSchema mappingSchema,
Type oracleBFileType,
Type oracleBinaryType,
Type oracleBlobType,
Type oracleClobType,
Type oracleDateType,
Type oracleDecimalType,
Type oracleIntervalDSType,
Type oracleIntervalYMType,
Type oracleStringType,
Type oracleTimeStampType,
Type oracleTimeStampLTZType,
Type oracleTimeStampTZType,
Type oracleXmlTypeType,
Type oracleXmlStreamType,
Type oracleRefCursorType,
Type?oracleRefType,
Func <string, OracleConnection> connectionCreator,
string typesNamespace,
Action <IDbDataParameter, OracleDbType> dbTypeSetter,
Func <IDbDataParameter, OracleDbType> dbTypeGetter,
Func <IDbConnection, string> hostNameGetter,
Func <IDbConnection, string> databaseNameGetter,
Action <IDbCommand, bool> bindByNameSetter,
Action <IDbCommand, int> arrayBindCountSetter,
Action <IDbCommand, int> initialLONGFetchSizeSetter,
Func <DateTimeOffset, string, object> createOracleTimeStampTZ,
Expression <Func <IDataReader, int, DateTimeOffset> > readDateTimeOffsetFromOracleTimeStampTZ,
Expression <Func <IDataReader, int, DateTimeOffset> > readDateTimeOffsetFromOracleTimeStampLTZ,
Expression <Func <IDataReader, int, decimal> > readOracleDecimalToDecimalAdv,
Expression <Func <IDataReader, int, int> > readOracleDecimalToInt,
Expression <Func <IDataReader, int, long> > readOracleDecimalToLong,
Expression <Func <IDataReader, int, decimal> > readOracleDecimalToDecimal,
BulkCopyAdapter?bulkCopy)
{
ConnectionType = connectionType;
DataReaderType = dataReaderType;
ParameterType = parameterType;
CommandType = commandType;
TransactionType = transactionType;
MappingSchema = mappingSchema;
OracleBFileType = oracleBFileType;
OracleBinaryType = oracleBinaryType;
OracleBlobType = oracleBlobType;
OracleClobType = oracleClobType;
OracleDateType = oracleDateType;
OracleDecimalType = oracleDecimalType;
OracleIntervalDSType = oracleIntervalDSType;
OracleIntervalYMType = oracleIntervalYMType;
OracleStringType = oracleStringType;
OracleTimeStampType = oracleTimeStampType;
OracleTimeStampLTZType = oracleTimeStampLTZType;
OracleTimeStampTZType = oracleTimeStampTZType;
OracleXmlTypeType = oracleXmlTypeType;
OracleXmlStreamType = oracleXmlStreamType;
OracleRefCursorType = oracleRefCursorType;
OracleRefType = oracleRefType;
_connectionCreator = connectionCreator;
ProviderTypesNamespace = typesNamespace;
SetDbType = dbTypeSetter;
GetDbType = dbTypeGetter;
GetHostName = hostNameGetter;
GetDatabaseName = databaseNameGetter;
SetBindByName = bindByNameSetter;
SetArrayBindCount = arrayBindCountSetter;
SetInitialLONGFetchSize = initialLONGFetchSizeSetter;
_createOracleTimeStampTZ = createOracleTimeStampTZ;
ReadDateTimeOffsetFromOracleTimeStampTZ = readDateTimeOffsetFromOracleTimeStampTZ;
ReadDateTimeOffsetFromOracleTimeStampLTZ = readDateTimeOffsetFromOracleTimeStampLTZ;
ReadOracleDecimalToDecimalAdv = readOracleDecimalToDecimalAdv;
ReadOracleDecimalToInt = readOracleDecimalToInt;
ReadOracleDecimalToLong = readOracleDecimalToLong;
ReadOracleDecimalToDecimal = readOracleDecimalToDecimal;
BulkCopy = bulkCopy;
}
static Expression GetMultipleQueryExpressionLazy(IBuildContext context, MappingSchema mappingSchema, Expression expression, HashSet <ParameterExpression> parameters)
{
expression.Visit(e =>
{
if (e.NodeType == ExpressionType.Lambda)
{
foreach (var p in ((LambdaExpression)e).Parameters)
{
parameters.Add(p);
}
}
});
// Convert associations.
//
return(expression.Transform(e =>
{
switch (e.NodeType)
{
case ExpressionType.MemberAccess :
{
var root = context.Builder.GetRootObject(e);
if (root != null &&
root.NodeType == ExpressionType.Parameter &&
!parameters.Contains((ParameterExpression)root))
{
var res = context.IsExpression(e, 0, RequestFor.Association);
if (res.Result)
{
var associationContext = (AssociationContext)res.Context !;
if (associationContext.Descriptor.IsList)
{
var me = (MemberExpression)e;
var parentType = me.Expression.Type;
var childType = me.Type;
var queryMethod = AssociationHelper.CreateAssociationQueryLambda(context.Builder,
new AccessorMember(me), associationContext.Descriptor, parentType, parentType, childType, false,
false, null, out _);
var dcConst = Expression.Constant(context.Builder.DataContext.Clone(true));
var expr = queryMethod.GetBody(me.Expression, dcConst);
if (e == expression)
{
expr = Expression.Call(
Methods.Enumerable.ToList.MakeGenericMethod(childType),
expr);
}
return expr;
}
}
}
break;
}
}
return e;
}));
}
private static DataConnection CreateOrderPositionsDbConnection()
{
var schema = new MappingSchema();
schema.GetFluentMappingBuilder()
.Entity<OrderPosition>()
.HasSchemaName("Billing")
.HasTableName("OrderPositions");
return new DataConnection("Source2").AddMappingSchema(schema);
}
public void HasPrimaryKey1()
{
var ms = new MappingSchema();
var mb = ms.GetFluentMappingBuilder();
mb.Entity<MyClass>().HasPrimaryKey(e => e.ID);
var ed = ms.GetEntityDescriptor(typeof(MyClass));
Assert.That(ed["ID"].IsPrimaryKey);
}
