public void DisplayProviderTypeProperties(IProviderType type, TreeNode indexNode)
{
if (this._currentHashCode == type.GetHashCode())
{
return;
}
propGrid.SelectedObject = type;
this._currentHashCode = type.GetHashCode();
}
public void ReferenceNavigationPropertyObjectContextMemberReturnsCorrectReferenceNav()
{
IProviderType entityType = TestGetProviderType("OrderDetail");
IProviderMember member = GetProviderMember(entityType.Members, "Order");
VerifyReferenceNavigationMember(member, "Order");
// rest of members are just primitives and are covered by testing other entity types, so don't need to repeat here
}
private bool StringConversionIsNeeded(IProviderType oldSqlType, IProviderType newSqlType)
{
if (!BothTypesAreStrings(oldSqlType, newSqlType))
{
return(true);
}
var flag = oldSqlType.IsFixedSize || newSqlType.IsFixedSize;
return(!newSqlType.HasSizeOrIsLarge || (OldWillFitInNew(oldSqlType, newSqlType) && flag));
}
// Fields
// Methods
internal SqlValue(Type clrType, IProviderType sqlType, object value, bool isClientSpecified, Expression sourceExpression)
: base(SqlNodeType.Value, clrType, sqlType, sourceExpression)
{
#if DEBUG
//if (sqlType.IsString && sqlType.GetType().Name != "AccessDataType")
// Debug.Assert(sqlType.Size > 0);
#endif
this.Value = value;
this.IsClientSpecified = isClientSpecified;
}
// Methods
internal SqlDiscriminatedType(IProviderType sqlType, SqlExpression discriminator, MetaType targetType, Expression sourceExpression)
: base(SqlNodeType.DiscriminatedType, typeof(Type), sourceExpression)
{
if (discriminator == null)
{
throw Error.ArgumentNull("discriminator");
}
this.discriminator = discriminator;
this.targetType = targetType;
this.sqlType = sqlType;
}
private void VerifyAddressMembers(IProviderType complexType)
{
IEnumerable <IProviderMember> members = GetMembers(complexType, 2);
IProviderMember member;
member = GetProviderMember(members, "StreetAddress");
VerifyPrimitiveMember(member, "String");
member = GetProviderMember(members, "ZipCode");
VerifyPrimitiveMember(member, "Int32");
}
protected virtual object GetParameterValue(IProviderType type, object value)
{
if (value == null)
{
return(DBNull.Value);
}
var type2 = value.GetType();
var closestRuntimeType = type.GetClosestRuntimeType();
return(closestRuntimeType == type2 ? value : DBConvert.ChangeType(value, closestRuntimeType));
}
//private int index = 0;
//internal override string CreateParameterName()
//{
// return (FirebirdIdentifier.Instance.ParameterPrefix + "p" + index++);
//}
#region MyRegion
//internal override SqlParameter InsertLookup(SqlValue cp)
//{
// SqlParameterInfo info;
// if (!map.TryGetValue(cp, out info))
// {
// var parameterName = cp.Value == null ? "NULL" : CreateParameterName();
// var parameter = new SqlParameter(cp.ClrType, cp.SqlType,
// parameterName,
// cp.SourceExpression);
// info = new SqlParameterInfo(parameter, cp.Value);
// map.Add(cp, info);
// currentParams.Add(info);
// }
// return info.Parameter;
//}
#endregion
internal override SqlStoredProcedureCall VisitStoredProcedureCall(SqlStoredProcedureCall spc)
{
VisitUserQuery(spc);
int num = 0;
int count = spc.Function.Parameters.Count;
while (num < count)
{
MetaParameter p = spc.Function.Parameters[num];
var node = spc.Arguments[num] as SqlParameter;
if (node != null)
{
node.Direction = GetParameterDirection(p);
Debug.Assert(!string.IsNullOrEmpty(p.MappedName));
node.Name = p.MappedName;
if ((node.Direction == ParameterDirection.InputOutput) ||
(node.Direction == ParameterDirection.Output))
{
RetypeOutParameter(node);
}
}
num++;
}
var returnType = spc.Function.Method.ReturnType;
if (returnType != typeof(void))
{
if (returnType.IsValueType || returnType == typeof(string))
{
IProviderType paramType = parameterizer.TypeProvider.From(returnType);
var parameter3 = new SqlParameter(returnType, paramType, ":RETURN_VALUE", spc.SourceExpression)
{
Direction = ParameterDirection.Output
};
currentParams.Add(new SqlParameterInfo(parameter3));
}
//else if (returnType.IsGenericType &&
// ((returnType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
// (returnType.GetGenericTypeDefinition() == typeof(ISingleResult<>))))
//{
// //paramType = parameterizer.TypeProvider.From(typeof(OracleRefCursor));
//}
//else
//{
// throw SqlClient.Error.InvalidReturnFromSproc(returnType);
//}
}
return(spc);
}
public override void InitializeParameter(IProviderType type, DbParameter parameter, object value)
{
base.InitializeParameter(type, parameter, value);
if (value is DateTime)
{
parameter.DbType = DbType.String;
}
if (value is bool)
{
parameter.DbType = DbType.Boolean;
parameter.Value = value;
}
}
protected IProviderType[] GetArgumentTypes(SqlFunctionCall fc)
{
var typeArray = new IProviderType[fc.Arguments.Count];
int index = 0;
int length = typeArray.Length;
while (index < length)
{
typeArray[index] = fc.Arguments[index].SqlType;
index++;
}
return(typeArray);
}
public override IProviderType GetBestType(IProviderType typeA, IProviderType typeB)
{
SqlTypeSystem.SqlType type = (typeA.ComparePrecedenceTo(typeB) > 0) ? ((SqlTypeSystem.SqlType)typeA) : ((ALinq.SqlClient.SqlTypeSystem.SqlType)typeB);
if (typeA.IsApplicationType || typeA.IsRuntimeOnlyType)
{
return(typeA);
}
if (typeB.IsApplicationType || typeB.IsRuntimeOnlyType)
{
return(typeB);
}
var type2 = (SqlTypeSystem.SqlType)typeA;
var type3 = (SqlTypeSystem.SqlType)typeB;
if ((type2.HasPrecisionAndScale && type3.HasPrecisionAndScale) && ((SqlDbType)type.SqlDbType == SqlDbType.Decimal))
{
int precision = type2.Precision;
int scale = type2.Scale;
int num3 = type3.Precision;
int num4 = type3.Scale;
if (((precision == 0) && (scale == 0)) && ((num3 == 0) && (num4 == 0)))
{
return(SqlTypeSystem.Create((SqlDbType)type.SqlDbType));
}
if ((precision == 0) && (scale == 0))
{
return(SqlTypeSystem.Create((SqlDbType)type.SqlDbType, num3, num4));
}
if ((num3 == 0) && (num4 == 0))
{
return(SqlTypeSystem.Create((SqlDbType)type.SqlDbType, precision, scale));
}
int num5 = Math.Max(precision - scale, num3 - num4);
int num6 = Math.Max(scale, num4);
int num7 = Math.Min(num5 + num6, 0x26);
return(SqlTypeSystem.Create((SqlDbType)type.SqlDbType, num7, num6));
}
int?size = null;
if (type2.Size.HasValue && type3.Size.HasValue)
{
int?nullable4 = type3.Size;
int?nullable5 = type2.Size;
size = ((nullable4.GetValueOrDefault() > nullable5.GetValueOrDefault()) && (nullable4.HasValue & nullable5.HasValue)) ? type3.Size : type2.Size;
}
if ((type3.Size.HasValue && (type3.Size.Value == -1)) || (type2.Size.HasValue && (type2.Size.Value == -1)))
{
size = -1;
}
return(new SqlTypeSystem.SqlType((SqlDbType)type.SqlDbType, size));
}
public override bool IsSameTypeFamily(IProviderType type)
{
var type2 = (MySqlType)type;
if (this.IsApplicationType)
{
return(false);
}
if (type2.IsApplicationType)
{
return(false);
}
return(this.Category == type2.Category);
}
public override void InitializeParameter(IProviderType type, DbParameter parameter, object value)
{
var parameter2 = parameter as OracleParameter;//System.Data.SqlClient.SqlParameter;
if (parameter2 == null)
{
base.InitializeParameter(type, parameter, value);
return;
}
var type2 = (SqlTypeSystem.SqlType)type;
if (type2.IsRuntimeOnlyType)
{
throw SqlClient.Error.BadParameterType(type2.GetClosestRuntimeType());
}
Debug.Assert(parameter2 != null);
parameter2.OracleDbType = ToOracleType((SqlDbType)type2.SqlDbType);
if (type2.HasPrecisionAndScale)
{
parameter2.Precision = (byte)type2.Precision;
parameter2.Scale = (byte)type2.Scale;
}
if (type2.HasPrecisionAndScale)
{
parameter2.Precision = (byte)type2.Precision;
parameter2.Scale = (byte)type2.Scale;
}
parameter.Value = GetParameterValue(type2, value);
if (!((parameter.Direction == ParameterDirection.Input) && type2.IsFixedSize) &&
(parameter.Direction == ParameterDirection.Input))
{
return;
}
if (type2.Size.HasValue)
{
if (parameter.Size < type2.Size)
{
parameter.Size = type2.Size.Value;
}
}
if (!type2.IsLargeType)
{
return;
}
}
// Methods
internal SqlGrouping(Type clrType, IProviderType sqlType, SqlExpression key, SqlExpression group, Expression sourceExpression)
: base(SqlNodeType.Grouping, clrType, sqlType, sourceExpression)
{
if (key == null)
{
throw Error.ArgumentNull("key");
}
if (group == null)
{
throw Error.ArgumentNull("group");
}
this.key = key;
this.group = group;
}
// Fields
// Methods
internal SqlParameter(Type clrType, IProviderType sqlType, string name, Expression sourceExpression)
: base(SqlNodeType.Parameter, clrType, sqlType, sourceExpression)
{
if (name == null)
{
throw Error.ArgumentNull("name");
}
if (typeof(Type).IsAssignableFrom(clrType))
{
throw Error.ArgumentWrongValue("clrType");
}
this.Name = name;
this.Direction = ParameterDirection.Input;
}
// Methods
internal SqlLink(object id, MetaType rowType, Type clrType, IProviderType sqlType, SqlExpression expression, MetaDataMember member, IEnumerable <SqlExpression> keyExpressions, SqlExpression expansion, Expression sourceExpression)
: base(SqlNodeType.Link, clrType, sqlType, sourceExpression)
{
this.id = id;
this.rowType = rowType;
this.expansion = expansion;
this.expression = expression;
this.member = member;
this.keyExpressions = new List <SqlExpression>();
if (keyExpressions != null)
{
this.keyExpressions.AddRange(keyExpressions);
}
}
bool IProviderType.IsSameTypeFamily(IProviderType type)
{
var type2 = (MySqlDataType)type;
if (IsApplicationType)
{
return(false);
}
if (type2.IsApplicationType)
{
return(false);
}
return(Category == type2.Category);
}
// Methods
internal SqlSubSelect(SqlNodeType nt, Type clrType, IProviderType sqlType, SqlSelect select)
: base(nt, clrType, sqlType, select.SourceExpression)
{
switch (nt)
{
case SqlNodeType.Element:
case SqlNodeType.Exists:
case SqlNodeType.Multiset:
case SqlNodeType.ScalarSubSelect:
this.Select = select;
return;
}
throw Error.UnexpectedNode(nt);
}
private SqlExpression ConvertToMax(SqlExpression expr, out bool changed)
{
changed = false;
if (expr.SqlType.IsLargeType)
{
IProviderType bestLargeType = this.sql.TypeProvider.GetBestLargeType(expr.SqlType);
changed = true;
if (expr.SqlType != bestLargeType)
{
return(this.ConvertToMax(expr, bestLargeType));
}
changed = false;
}
return(expr);
}
// Methods
internal SqlLike(Type clrType, IProviderType sqlType, SqlExpression expr, SqlExpression pattern, SqlExpression escape, Expression source)
: base(SqlNodeType.Like, clrType, sqlType, source)
{
if (expr == null)
{
throw Error.ArgumentNull("expr");
}
if (pattern == null)
{
throw Error.ArgumentNull("pattern");
}
this.Expression = expr;
this.Pattern = pattern;
this.Escape = escape;
}
// Methods
internal SqlMethodCall(Type clrType, IProviderType sqlType, MethodInfo method, SqlExpression obj, IEnumerable <SqlExpression> args, Expression sourceExpression)
: base(SqlNodeType.MethodCall, clrType, sqlType, sourceExpression)
{
if (method == null)
{
throw Error.ArgumentNull("method");
}
this.method = method;
Object = obj;
arguments = new List <SqlExpression>();
if (args != null)
{
arguments.AddRange(args);
}
}
internal bool RetypeOutParameter(SqlParameter node)
{
if (node.SqlType.IsLargeType)
{
IProviderType bestLargeType = this.parameterizer.TypeProvider.GetBestLargeType(node.SqlType);
if (node.SqlType != bestLargeType)
{
node.SetSqlType(bestLargeType);
return(true);
}
this.parameterizer.Annotations.Add(node, new SqlServerCompatibilityAnnotation(Strings.MaxSizeNotSupported(node.SourceExpression),
new[] { SqlProvider.ProviderMode.Sql2000 }));
}
return(false);
}
protected override object GetParameterValue(IProviderType type, object value)
{
if (value == null)
{
return(DBNull.Value);
}
var type2 = value.GetType();
var closestRuntimeType = type.GetClosestRuntimeType();
if (closestRuntimeType == typeof(OracleNumber))
{
return(new OracleNumber(Convert.ToDecimal(value)));
}
return(closestRuntimeType == type2 ? value : DBConvert.ChangeType(value, closestRuntimeType));
}
internal static object InheritanceCodeForClientCompare(object rawCode, IProviderType providerType)
{
if (!providerType.IsFixedSize || (rawCode.GetType() != typeof(string)))
{
return(rawCode);
}
var str = (string)rawCode;
if (providerType.Size.HasValue)
{
if (str.Length != providerType.Size)
{
str = str.PadRight(providerType.Size.Value).Substring(0, providerType.Size.Value);
}
}
return(str);
}
//internal SqlColumn(string name, Expression expr)
// : this(expr.ClrType, expr.SqlType, name, null, expr, expr.SourceExpression)
//{
//}
internal SqlColumn(Type clrType, IProviderType sqlType, string name, MetaDataMember member, SqlExpression expr, Expression sourceExpression)
: base(SqlNodeType.Column, clrType, sourceExpression)
{
if (typeof(Type).IsAssignableFrom(clrType))
{
throw Error.ArgumentWrongValue("clrType");
}
this.name = name;
MetaMember = member;
Expression = expr;
Ordinal = -1;
if (sqlType == null)
{
throw Error.ArgumentNull("sqlType");
}
this.sqlType = sqlType;
}
private void VerifyOrderMembers(IProviderType entityType)
{
IEnumerable <IProviderMember> members = GetMembers(entityType, 5);
IProviderMember member;
member = GetProviderMember(members, "OrderID");
VerifyPrimitiveMember(member, "Int32", expectedIsKey: true);
member = GetProviderMember(members, "OrderDate");
VerifyPrimitiveMember(member, "DateTime");
member = GetProviderMember(members, "Description");
VerifyPrimitiveMember(member, "String", expectedMimeType: "text/plain");
member = GetProviderMember(members, "ShippingAddress");
VerifyComplexMember(member, "Address");
member = GetProviderMember(members, "OrderDetails");
VerifyCollectionNavigationMember(member, "OrderDetail");
}
// Methods
internal SqlTypeCase(Type clrType, IProviderType sqlType, MetaType rowType,
SqlExpression discriminator, IEnumerable <SqlTypeCaseWhen> whens, Expression sourceExpression)
: base(SqlNodeType.TypeCase, clrType, sourceExpression)
{
this.Whens = new List <SqlTypeCaseWhen>();
this.Discriminator = discriminator;
if (whens == null)
{
throw Error.ArgumentNull("whens");
}
this.Whens.AddRange(whens);
if (this.Whens.Count == 0)
{
throw Error.ArgumentOutOfRange("whens");
}
this.sqlType = sqlType;
this.RowType = rowType;
}
public void DisplayProviderTypeProperties(IProviderType type, TreeNode indexNode)
{
if (this._currentHashCode == type.GetHashCode())
{
return;
}
DataTable dt = new DataTable("MyData");
dt.Columns.Add("Property", stringType);
dt.Columns.Add("Value", stringType);
dt.Rows.Add(new object[] { "Type", type.Type });
dt.Rows.Add(new object[] { "DataType", type.DataType.ToString() });
dt.Rows.Add(new object[] { "ColumnSize", type.ColumnSize.ToString() });
dt.Rows.Add(new object[] { "LiteralPrefix", type.LiteralPrefix });
dt.Rows.Add(new object[] { "LiteralSuffix", type.LiteralSuffix });
dt.Rows.Add(new object[] { "CreateParams", type.CreateParams });
dt.Rows.Add(new object[] { "IsNullable", type.IsNullable ? "True" : "False" });
dt.Rows.Add(new object[] { "IsCaseSensitive", type.IsCaseSensitive ? "True" : "False" });
// dt.Rows.Add(new object[] {"Searchable", type.Searchable});
dt.Rows.Add(new object[] { "IsUnsigned", type.IsUnsigned ? "True" : "False" });
dt.Rows.Add(new object[] { "HasFixedPrecScale", type.HasFixedPrecScale ? "True" : "False" });
dt.Rows.Add(new object[] { "CanBeAutoIncrement", type.CanBeAutoIncrement ? "True" : "False" });
dt.Rows.Add(new object[] { "LocalType", type.LocalType });
dt.Rows.Add(new object[] { "MinimumScale", type.MinimumScale.ToString() });
dt.Rows.Add(new object[] { "MaximumScale", type.MaximumScale.ToString() });
dt.Rows.Add(new object[] { "TypeGuid", type.TypeGuid.ToString() });
dt.Rows.Add(new object[] { "TypeLib", type.TypeLib });
dt.Rows.Add(new object[] { "Version", type.Version });
dt.Rows.Add(new object[] { "IsLong", type.IsLong ? "True" : "False" });
dt.Rows.Add(new object[] { "BestMatch", type.BestMatch ? "True" : "False" });
dt.Rows.Add(new object[] { "IsFixedLength", type.IsFixedLength ? "True" : "False" });
this.Grid.DataSource = dt;
this.InitializeGrid();
this.Text = "IProviderType Properties";
this.lnkHELP.Text = "IProviderType Help ...";
this.helpInterface = "IProviderType";
this._currentHashCode = type.GetHashCode();
}
internal override SqlExpression VisitSimpleCase(SqlSimpleCase c)
{
base.VisitSimpleCase(c);
IProviderType type = c.Whens[0].Value.SqlType;
for (int i = 1; i < c.Whens.Count; i++)
{
IProviderType sqlType = c.Whens[i].Value.SqlType;
type = this.typeProvider.GetBestType(type, sqlType);
}
foreach (SqlWhen when in c.Whens.Where(delegate(SqlWhen w)
{
//return (w.Value.SqlType != type) && !w.Value.SqlType.IsRuntimeOnlyType;
//MY Code
return((Convert.ToInt32(w.Value.SqlType.SqlDbType) != Convert.ToInt32(type.SqlDbType)) && !w.Value.SqlType.IsRuntimeOnlyType);
//======================
}))
{
when.Value = SqlFactory.UnaryConvert(when.Value.ClrType, type, when.Value, when.Value.SourceExpression);
}
return(c);
}
internal override SqlExpression VisitFunctionCall(SqlFunctionCall fc)
{
if (fc.Name == "Limit")
{
return(fc);
}
int num = 0;
int count = fc.Arguments.Count;
while (num < count)
{
fc.Arguments[num] = VisitExpression(fc.Arguments[num]);
num++;
}
if ((fc.Arguments.Count > 0) && (fc.Arguments[0].SqlType != null))
{
IProviderType type = typeProvider.ReturnTypeOfFunction(fc);
if (type != null)
{
fc.SetSqlType(type);
}
}
return(fc);
}
public void DisplayProviderTypeProperties(IProviderType type, TreeNode indexNode)
{
if (this._currentHashCode == type.GetHashCode()) return;
propGrid.SelectedObject = type;
this._currentHashCode = type.GetHashCode();
}
private void VerifyAddressMembers(IProviderType complexType)
{
IEnumerable<IProviderMember> members = GetMembers(complexType, 2);
IProviderMember member;
member = GetProviderMember(members, "StreetAddress");
VerifyPrimitiveMember(member, "String");
member = GetProviderMember(members, "ZipCode");
VerifyPrimitiveMember(member, "Int32");
}
private void VerifySpecialOrderMembers(IProviderType entityType)
{
IEnumerable<IProviderMember> members = GetMembers(entityType, 1);
IProviderMember member = GetProviderMember(members, "CustomInstructions");
VerifyPrimitiveMember(member, "String");
}
private void VerifyOrderMembers(IProviderType entityType)
{
IEnumerable<IProviderMember> members = GetMembers(entityType, 5);
IProviderMember member;
member = GetProviderMember(members, "OrderID");
VerifyPrimitiveMember(member, "Int32", expectedIsKey : true);
member = GetProviderMember(members, "OrderDate");
VerifyPrimitiveMember(member, "DateTime");
member = GetProviderMember(members, "Description");
VerifyPrimitiveMember(member, "String", expectedMimeType : "text/plain");
member = GetProviderMember(members, "ShippingAddress");
VerifyComplexMember(member, "Address");
member = GetProviderMember(members, "OrderDetails");
VerifyCollectionNavigationMember(member, "OrderDetail");
}
private static void VerifyProviderType(string typeName, IProviderType providerType)
{
Assert.IsNotNull(providerType, "Unable to get the provider type {0} from the metadata workspace.", typeName);
Assert.AreEqual(typeName, providerType.Name, "IProviderType.Name is incorrect for type {0}.", typeName);
}
private static IEnumerable<IProviderMember> GetMembers(IProviderType providerType, int expectedMemberCount)
{
IEnumerable<IProviderMember> members = providerType.Members;
Assert.AreEqual(expectedMemberCount, members.Count(), "Provider type {0} does not have the expected number of members.", providerType.Name);
return members;
}
public void DisplayProviderTypeProperties(IProviderType type, TreeNode indexNode)
{
DataTable dt = new DataTable("MyData");
dt.Columns.Add("Property", stringType);
dt.Columns.Add("Value", stringType);
dt.Rows.Add(new object[] {"Type", type.Type});
dt.Rows.Add(new object[] {"DataType", type.DataType.ToString()});
dt.Rows.Add(new object[] {"ColumnSize", type.ColumnSize.ToString()});
dt.Rows.Add(new object[] {"LiteralPrefix", type.LiteralPrefix});
dt.Rows.Add(new object[] {"LiteralSuffix", type.LiteralSuffix});
dt.Rows.Add(new object[] {"CreateParams", type.CreateParams});
dt.Rows.Add(new object[] {"IsNullable", type.IsNullable ? "True" : "False"});
dt.Rows.Add(new object[] {"IsCaseSensitive", type.IsCaseSensitive ? "True" : "False"});
// dt.Rows.Add(new object[] {"Searchable", type.Searchable});
dt.Rows.Add(new object[] {"IsUnsigned", type.IsUnsigned ? "True" : "False"});
dt.Rows.Add(new object[] {"HasFixedPrecScale", type.HasFixedPrecScale ? "True" : "False"});
dt.Rows.Add(new object[] {"CanBeAutoIncrement", type.CanBeAutoIncrement ? "True" : "False"});
dt.Rows.Add(new object[] {"LocalType", type.LocalType});
dt.Rows.Add(new object[] {"MinimumScale", type.MinimumScale.ToString()});
dt.Rows.Add(new object[] {"MaximumScale", type.MaximumScale.ToString()});
dt.Rows.Add(new object[] {"TypeGuid", type.TypeGuid.ToString()});
dt.Rows.Add(new object[] {"TypeLib", type.TypeLib});
dt.Rows.Add(new object[] {"Version", type.Version});
dt.Rows.Add(new object[] {"IsLong", type.IsLong ? "True" : "False"});
dt.Rows.Add(new object[] {"BestMatch", type.BestMatch ? "True" : "False"});
dt.Rows.Add(new object[] {"IsFixedLength", type.IsFixedLength ? "True" : "False"});
this.Grid.DataSource = dt;
this.InitializeGrid();
this.Text = "IProviderType Properties";
this.lnkHELP.Text = "IProviderType Help ...";
this.helpInterface = "IProviderType";
}
