C# ProviderType.IsSameTypeFamily方法代码示例

		private bool BothTypesAreStrings(ProviderType oldSqlType, ProviderType newSqlType)
		{
			bool result = oldSqlType.IsSameTypeFamily(sql.TypeProvider.From(typeof(string)))
				&& newSqlType.IsSameTypeFamily(sql.TypeProvider.From(typeof(string)));

			return result;
		}

		internal override ProviderType ChangeTypeFamilyTo(ProviderType type, ProviderType toType)
		{
			// if this is already the same family, do nothing
			if(type.IsSameTypeFamily(toType))
				return type;

			// otherwise as a default return toType
			// but look for special cases we have to convert carefully
			if(type.IsApplicationType || toType.IsApplicationType)
				return toType;
			SqlType sqlToType = (SqlType)toType;
			SqlType sqlThisType = (SqlType)type;

			if(sqlToType.Category == TypeCategory.Numeric && sqlThisType.Category == TypeCategory.Char)
			{
				switch(sqlThisType.SqlDbType)
				{
					case SqlDbType.NChar:
						return SqlTypeSystem.Create(SqlDbType.Int);
					case SqlDbType.Char:
						return SqlTypeSystem.Create(SqlDbType.SmallInt);
					default:
						return toType;
				}
			}
			else
			{
				return toType;
			}
		}

		internal override ProviderType PredictTypeForBinary(SqlNodeType binaryOp, ProviderType leftType, ProviderType rightType)
		{
			SqlType highest;

			if(leftType.IsSameTypeFamily(this.From(typeof(string))) && rightType.IsSameTypeFamily(this.From(typeof(string))))
			{
				highest = (SqlType)this.GetBestType(leftType, rightType);
			}
			else
			{
				int coercionPrecedence = leftType.ComparePrecedenceTo(rightType);
				highest = (SqlType)(coercionPrecedence > 0 ? leftType : rightType);
			}

			switch(binaryOp)
			{
				case SqlNodeType.Add:
				case SqlNodeType.Sub:
				case SqlNodeType.Mul:
				case SqlNodeType.Div:
				case SqlNodeType.BitAnd:
				case SqlNodeType.BitOr:
				case SqlNodeType.BitXor:
				case SqlNodeType.Mod:
				case SqlNodeType.Coalesce:
					return highest;
				case SqlNodeType.Concat:
					// When concatenating two types with size, the result type after
					// concatenation must have a size equal to the sum of the two sizes.
					if(highest.HasSizeOrIsLarge)
					{
						// get the best type, specifying null for size so we get
						// the maximum allowable size
						ProviderType concatType = this.GetBestType(highest.SqlDbType, null);

						if((!leftType.IsLargeType && leftType.Size.HasValue) &&
						   (!rightType.IsLargeType && rightType.Size.HasValue))
						{
							// If both types are not large types and have size, and the
							// size is less than the default size, return the shortened type.
							int concatSize = leftType.Size.Value + rightType.Size.Value;
							if((concatSize < concatType.Size) || concatType.IsLargeType)
							{
								return GetBestType(highest.SqlDbType, concatSize);
							}
						}

						return concatType;
					}
					return highest;
				case SqlNodeType.And:
				case SqlNodeType.Or:
				case SqlNodeType.LT:
				case SqlNodeType.LE:
				case SqlNodeType.GT:
				case SqlNodeType.GE:
				case SqlNodeType.EQ:
				case SqlNodeType.NE:
				case SqlNodeType.EQ2V:
				case SqlNodeType.NE2V:
					return ProviderConstants.IntType;
				default:
					throw Error.UnexpectedNode(binaryOp);
			}
		}