public SqlDataType(SqlDataTypeOption type, bool isMax = false) : this()
{
Type = type;
IsMax = isMax;
Size = null;
Scale = null;
}
public SqlDataType(SqlDataTypeOption type, int size) : this()
{
Type = type;
IsMax = false;
Size = size;
Scale = null;
}
public static SqlDataType Parse(string value)
{
var match = Regex.Match(value, "(?<Name>[a-zA-Z_]*)(\\((?<Parameters>.*)\\))?");
var match2 = Regex.Match(value, "\\((?<Parameters>.*)\\)");
string name = match.Groups["Name"].Value.ToLower().Trim();
string parameters = match.Groups["Parameters"].Value;
SqlDataTypeOption option = name.ToSqlDataTypeOption();
if (!string.IsNullOrEmpty(parameters))
{
string cleanParamters = parameters.Trim().ToLower().Replace(" ", string.Empty);
if (cleanParamters == "max")
{
return(new SqlDataType(option, true));
}
if (cleanParamters.Contains(","))
{
string[] split = cleanParamters.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int size = int.Parse(split[0]);
int scale = int.Parse(split[1]);
return(new SqlDataType(option, size, scale));
}
else
{
int size = int.Parse(cleanParamters);
return(new SqlDataType(option, size));
}
}
return(new SqlDataType(option));
}
public SqlDataType(SqlDataTypeOption type, int size, int scale)
{
Type = type;
IsMax = false;
Size = size;
Scale = scale;
}
private bool ShouldParamterize(SqlDataTypeOption sqlDataTypeOption)
{
switch (sqlDataTypeOption)
{
case SqlDataTypeOption.BigInt:
case SqlDataTypeOption.Int:
case SqlDataTypeOption.SmallInt:
case SqlDataTypeOption.TinyInt:
case SqlDataTypeOption.Bit:
case SqlDataTypeOption.Decimal:
case SqlDataTypeOption.Numeric:
case SqlDataTypeOption.Money:
case SqlDataTypeOption.SmallMoney:
case SqlDataTypeOption.Float:
case SqlDataTypeOption.Real:
case SqlDataTypeOption.DateTime:
case SqlDataTypeOption.SmallDateTime:
case SqlDataTypeOption.Char:
case SqlDataTypeOption.VarChar:
case SqlDataTypeOption.NChar:
case SqlDataTypeOption.NVarChar:
case SqlDataTypeOption.Binary:
case SqlDataTypeOption.VarBinary:
case SqlDataTypeOption.UniqueIdentifier:
case SqlDataTypeOption.Date:
case SqlDataTypeOption.Time:
case SqlDataTypeOption.DateTime2:
case SqlDataTypeOption.DateTimeOffset:
return(true);
default:
return(false);
}
}
public static SqlDataTypeReference DataType(SqlDataTypeOption option, IEnumerable <Literal> parameters)
{
var fragment = new SqlDataTypeReference();
fragment.SqlDataTypeOption = option;
fragment.Parameters.AddRange(parameters);
return(fragment);
}
public static SqlDataTypeReference SqlDataType(SqlDataTypeOption option, params Literal[] parameters)
{
var fragment = new SqlDataTypeReference();
fragment.SqlDataTypeOption = option;
fragment.Parameters.AddRange(parameters);
return(fragment);
}
public void Reset()
{
SqlDataTypeOption = SqlDataTypeOption.VarChar;
SqlDataTypeParameters = null;
VariableName = null;
IsNegative = false;
Parameters.Clear();
}
private static int GetDtoIndex(SqlDataTypeOption dto)
{
return indexOfDTO[dto];
}
internal static bool IsHigherPrecedence(SqlDataTypeOption t1, SqlDataTypeOption t2)
{
int precedenceOfType1 = 0;
precedenceTable.TryGetValue(t1, out precedenceOfType1);
int precedenceOfType2 = 0;
precedenceTable.TryGetValue(t2, out precedenceOfType2);
return precedenceOfType1 < precedenceOfType2;
}
public static TypeConversionResult GetConversionResult(SqlDataTypeOption from, SqlDataTypeOption to)
{
TypeConversionResult result = TypeConversionResult.NotImplemented;
try
{
int fromIndex = GetDtoIndex(from);
int toIndex = GetDtoIndex(to);
result = conversionTableArray[fromIndex, toIndex];
}
catch(KeyNotFoundException)
{
// an unknown sql data type option - default not implemented
return result;
}
return result;
}
public static SqlDataTypeReference DataType(SqlDataTypeOption option, int size, int scale)
{
return(DataType(option, Integer(size), Integer(scale)));
}
public void AllNumericToStringConversionsCheckConvertedLength(SqlDataTypeOption numericType, SqlDataTypeOption stringType)
{
var result = TypeConversionHelper.GetConversionResult(numericType, stringType);
(result & TypeConversionResult.CheckConvertedLength).Should().NotBe(0, "converting {0} to {1} should check length", numericType, stringType);
}
public static SqlDataTypeReference SqlDataType(SqlDataTypeOption option, int size, int scale)
{
return(SqlDataType(option, IntegerLiteral(size.ToString()), IntegerLiteral(scale.ToString())));
}
public static SqlDataTypeReference SqlDataType(SqlDataTypeOption option, bool max)
{
return(max ? SqlDataType(option, MaxLiteral("MAX")) : SqlDataType(option));
}
private void AddToParameterCollection(Literal literal, string parameterName, SqlDataTypeOption sqlDataTypeOption, IList <Literal> sqlDataTypeParameters)
{
SqlParameter sqlParameter = new SqlParameter();
string literalValue = literal.Value;
object parsedValue = null;
SqlDbType paramType = SqlDbType.VarChar;
bool parseSuccessful = true;
switch (sqlDataTypeOption)
{
case SqlDataTypeOption.Binary:
paramType = SqlDbType.Binary;
try
{
parsedValue = TryParseBinaryLiteral(literalValue, VariableName, SqlDbType.Binary, literal.StartLine);
}
catch (ParameterizationFormatException)
{
if (IsCodeSenseRequest)
{
parseSuccessful = false;
AddCodeSenseErrorItem(MessageHelper.MessageType.BINARY_LITERAL_PREFIX_MISSING_ERROR, literal, literal.Value, VariableName, SqlDbType.Binary.ToString());
}
else
{
throw;
}
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Binary.ToString(), C_SHARP_BYTE_ARRAY, literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.VarBinary:
paramType = SqlDbType.VarBinary;
try
{
parsedValue = TryParseBinaryLiteral(literalValue, VariableName, SqlDbType.VarBinary, literal.StartLine);
ExtractSize(sqlDataTypeParameters, sqlParameter);
}
catch (ParameterizationFormatException)
{
if (IsCodeSenseRequest)
{
parseSuccessful = false;
string sqlDataTypeString = GetSqlDataTypeStringOneParameter(SqlDbType.VarBinary, sqlDataTypeParameters);
AddCodeSenseErrorItem(MessageHelper.MessageType.BINARY_LITERAL_PREFIX_MISSING_ERROR, literal, literalValue, VariableName, sqlDataTypeString);
}
else
{
throw;
}
}
catch (Exception e)
{
parseSuccessful = false;
string sqlDataTypeString = GetSqlDataTypeStringOneParameter(SqlDbType.VarBinary, sqlDataTypeParameters);
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, sqlDataTypeString, C_SHARP_BYTE_ARRAY, literalValue, literal.StartLine, e);
}
break;
//Integer literals of form 24.0 will not be supported
case SqlDataTypeOption.BigInt:
paramType = SqlDbType.BigInt;
long parsedLong;
literalValue = IsNegative ? "-" + literalValue : literalValue;
if (long.TryParse(literalValue, out parsedLong))
{
parsedValue = parsedLong;
}
else
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.BigInt.ToString(), "Int64", literalValue, literal.StartLine, null);
}
break;
case SqlDataTypeOption.Int:
paramType = SqlDbType.Int;
int parsedInt;
literalValue = IsNegative ? "-" + literalValue : literalValue;
if (int.TryParse(literalValue, out parsedInt))
{
parsedValue = parsedInt;
}
else
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Int.ToString(), "Int32", literalValue, literal.StartLine, null);
}
break;
case SqlDataTypeOption.SmallInt:
paramType = SqlDbType.SmallInt;
short parsedShort;
literalValue = IsNegative ? "-" + literalValue : literalValue;
if (short.TryParse(literalValue, out parsedShort))
{
parsedValue = parsedShort;
}
else
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.SmallInt.ToString(), "Int16", literalValue, literal.StartLine, null);
}
break;
case SqlDataTypeOption.TinyInt:
paramType = SqlDbType.TinyInt;
byte parsedByte;
literalValue = IsNegative ? "-" + literalValue : literalValue;
if (byte.TryParse(literalValue, out parsedByte))
{
parsedValue = parsedByte;
}
else
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.TinyInt.ToString(), "Byte", literalValue, literal.StartLine, null);
}
break;
case SqlDataTypeOption.Real:
paramType = SqlDbType.Real;
literalValue = IsNegative ? "-" + literalValue : literalValue;
try
{
parsedValue = SqlSingle.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Real.ToString(), "SqlSingle", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.Float:
paramType = SqlDbType.Float;
literalValue = IsNegative ? "-" + literalValue : literalValue;
try
{
parsedValue = SqlDouble.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Float.ToString(), "SqlDouble", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.Decimal:
case SqlDataTypeOption.Numeric:
paramType = SqlDbType.Decimal;
ExtractPrecisionAndScale(sqlDataTypeParameters, sqlParameter);
literalValue = IsNegative ? "-" + literalValue : literalValue;
try
{
parsedValue = SqlDecimal.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
string sqlDecimalDataType = sqlDataTypeParameters != null ? (SqlDbType.Decimal + "(" + sqlDataTypeParameters[0] + ", " + sqlDataTypeParameters[1] + ")") : "";
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, sqlDecimalDataType, "SqlDecimal", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.Money:
paramType = SqlDbType.Money;
literalValue = IsNegative ? "-" + literalValue : literalValue;
try
{
parsedValue = SqlMoney.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Money.ToString(), "SqlMoney", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.SmallMoney:
paramType = SqlDbType.SmallMoney;
literalValue = IsNegative ? "-" + literalValue : literalValue;
try
{
parsedValue = SqlMoney.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.SmallMoney.ToString(), "SqlMoney", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.DateTime:
paramType = SqlDbType.DateTime;
try
{
parsedValue = ParseDateTime(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.DATE_TIME_ERROR_MESSAGE, literal, VariableName, SqlDbType.DateTime.ToString(), "DateTime", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.SmallDateTime:
paramType = SqlDbType.SmallDateTime;
try
{
parsedValue = ParseDateTime(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.DATE_TIME_ERROR_MESSAGE, literal, VariableName, SqlDbType.SmallDateTime.ToString(), "DateTime", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.DateTime2:
paramType = SqlDbType.DateTime2;
try
{
parsedValue = ParseDateTime(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.DATE_TIME_ERROR_MESSAGE, literal, VariableName, SqlDbType.DateTime2.ToString(), "DateTime", literalValue, literal.StartLine, e);
}
ExtractPrecision(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.Date:
paramType = SqlDbType.Date;
try
{
parsedValue = ParseDate(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.DATE_TIME_ERROR_MESSAGE, literal, VariableName, SqlDbType.Date.ToString(), "DateTime", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.DateTimeOffset:
paramType = SqlDbType.DateTimeOffset;
try
{
parsedValue = ParseDateTimeOffset(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.DATE_TIME_ERROR_MESSAGE, literal, VariableName, SqlDbType.DateTimeOffset.ToString(), "DateTimeOffset", literalValue, literal.StartLine, e);
}
ExtractPrecision(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.Time:
paramType = SqlDbType.Time;
try
{
parsedValue = TimeSpan.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Time.ToString(), "TimeSpan", literalValue, literal.StartLine, e);
}
ExtractPrecision(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.Char:
paramType = SqlDbType.Char;
ExtractSize(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.VarChar:
paramType = SqlDbType.VarChar;
ExtractSize(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.NChar:
paramType = SqlDbType.NChar;
ExtractSize(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.NVarChar:
paramType = SqlDbType.NVarChar;
ExtractSize(sqlDataTypeParameters, sqlParameter);
break;
case SqlDataTypeOption.UniqueIdentifier:
paramType = SqlDbType.UniqueIdentifier;
try
{
parsedValue = SqlGuid.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.UniqueIdentifier.ToString(), "SqlGuid", literalValue, literal.StartLine, e);
}
break;
case SqlDataTypeOption.Bit:
paramType = SqlDbType.Bit;
try
{
parsedValue = Byte.Parse(literalValue);
}
catch (Exception e)
{
parseSuccessful = false;
HandleError(MessageHelper.MessageType.ERROR_MESSAGE, literal, VariableName, SqlDbType.Bit.ToString(), "Byte", literalValue, literal.StartLine, e);
}
break;
default:
break;
}
if (parseSuccessful)
{
sqlParameter.ParameterName = parameterName;
sqlParameter.SqlDbType = paramType;
sqlParameter.Value = parsedValue ?? literalValue;
sqlParameter.Direction = ParameterDirection.Input;
Parameters.Add(sqlParameter);
}
}
public override void ExplicitVisit(DeclareVariableStatement node)
{
if (node == null || node.Declarations == null)
{
return;
}
StringBuilder codeSenseMessageStringBuilder = new StringBuilder();
int endLine = -1;
int endCol = -1;
foreach (DeclareVariableElement declareVariableElement in node.Declarations)
{
if (declareVariableElement.DataType is SqlDataTypeReference dataTypeReference)
{
SqlDataTypeOption sqlDataTypeOption = dataTypeReference.SqlDataTypeOption;
if (ShouldParamterize(sqlDataTypeOption))
{
IList <Literal> sqlDataTypeParameters = dataTypeReference.Parameters;
ScalarExpressionTransformer.SqlDataTypeOption = sqlDataTypeOption;
ScalarExpressionTransformer.SqlDataTypeParameters = sqlDataTypeParameters;
ScalarExpressionTransformer.VariableName = declareVariableElement.VariableName.Value;
ScalarExpression declareVariableElementValue = declareVariableElement.Value;
ScalarExpressionTransformer.ExplicitVisit(declareVariableElementValue);
declareVariableElement.Value = ScalarExpressionTransformer.GetTransformedExpression();
IList <SqlParameter> sqlParameters = ScalarExpressionTransformer.Parameters;
if (sqlParameters.Count == 1 && declareVariableElementValue != null)
{
codeSenseMessageStringBuilder.Append(SR.ParameterizationDetails(declareVariableElement.VariableName.Value,
sqlParameters[0].SqlDbType.ToString(),
sqlParameters[0].Size,
sqlParameters[0].Precision,
sqlParameters[0].Scale,
sqlParameters[0].SqlValue.ToString()));
endLine = declareVariableElementValue.StartLine;
endCol = declareVariableElementValue.StartColumn + declareVariableElementValue.FragmentLength;
if (!IsCodeSenseRequest)
{
string sqlParameterKey = sqlParameters[0].SqlDbType.ToString();
ExecutionParameters.TryGetValue(sqlParameterKey, out int currentCount);
ExecutionParameters[sqlParameterKey] = currentCount + 1;
}
}
Parameters.AddRange(sqlParameters);
ScalarExpressionTransformer.Reset();
}
}
}
if (codeSenseMessageStringBuilder.Length > 0)
{
CodeSenseMessages.Add(new ScriptFileMarker
{
Level = ScriptFileMarkerLevel.Information,
Message = codeSenseMessageStringBuilder.ToString(),
ScriptRegion = new ScriptRegion
{
StartLineNumber = node.StartLine,
StartColumnNumber = node.StartColumn,
EndLineNumber = endLine == -1 ? node.StartLine : endLine,
EndColumnNumber = endCol == -1 ? node.StartColumn + node.LastTokenIndex - node.FirstTokenIndex : endCol
}
});
}
node.AcceptChildren(this);
base.ExplicitVisit(node); // let the base class finish up
}
public void AllWideStringToStringConversionsCheckNarrowing(SqlDataTypeOption t1, SqlDataTypeOption t2)
{
var result = TypeConversionHelper.GetConversionResult(t1, t2);
(result & TypeConversionResult.Narrowing).Should().NotBe(0, "converting {0} to {1} should warn about narrowing", t1, t2);
}
public static SqlDataTypeReference DataType(SqlDataTypeOption option, bool max)
{
return(max ? DataType(option, Max()) : DataType(option));
}
public void AllStringToStringConversionsCheckLength(SqlDataTypeOption t1, SqlDataTypeOption t2)
{
var result = TypeConversionHelper.GetConversionResult(t1, t2);
(result & TypeConversionResult.CheckLength).Should().NotBe(0, "converting {0} to {1} should check length", t1, t2);
}
public static SqlDataTypeReference DataType(SqlDataTypeOption option, params Literal[] parameters)
{
return(DataType(option, (IEnumerable <Literal>)parameters));
}
