public void Parse() { try { SqlSingle.Parse(null); Assert.Fail("#L01"); } catch (Exception e) { Assert.AreEqual(typeof(ArgumentNullException), e.GetType(), "#L02"); } try { SqlSingle.Parse("not-a-number"); Assert.Fail("#L03"); } catch (Exception e) { Assert.AreEqual(typeof(FormatException), e.GetType(), "#L04"); } try { SqlSingle.Parse("9e44"); Assert.Fail("#L05"); } catch (Exception e) { Assert.AreEqual(typeof(OverflowException), e.GetType(), "#L06"); } Assert.AreEqual((float)150, SqlSingle.Parse("150").Value, "#L07"); }
public void Parse() { try { SqlSingle.Parse(null); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(ArgumentNullException), e.GetType()); } try { SqlSingle.Parse("not-a-number"); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(FormatException), e.GetType()); } try { SqlSingle.Parse("9e44"); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(OverflowException), e.GetType()); } Assert.Equal(150, SqlSingle.Parse("150").Value); }
public void Parse() { Assert.Throws <ArgumentNullException>(() => SqlSingle.Parse(null)); Assert.Throws <FormatException>(() => SqlSingle.Parse("not-a-number")); Assert.Throws <OverflowException>(() => SqlSingle.Parse("9e44")); Assert.Equal(150, SqlSingle.Parse("150").Value); }
/// <summary> /// /// </summary> /// <param name="s"></param> /// <param name="type"></param> /// <returns></returns> public static PSingle Parse(string s, PValueType type) { PSingle sp; if (string.IsNullOrEmpty(s)) { sp = new PSingle(type); } else { sp = SqlSingle.Parse(s); } return(sp); }
public static PSingle Parse(string s, PValueType type) { var sp = string.IsNullOrEmpty(s) ? new PSingle(type) : SqlSingle.Parse(s); return(sp); }
public static SqlSingleRegularArray Parse(SqlString s) { if (s.IsNull) { return(Null); } return(new SqlSingleRegularArray(SqlFormatting.ParseRegular <Single?>(s.Value, t => !t.Equals(SqlFormatting.NullText, StringComparison.InvariantCultureIgnoreCase) ? SqlSingle.Parse(t).Value : default(Single?)))); }
public override object FromStringValue(string xml) { return(SqlSingle.Parse(xml)); }
private bool CheckColumnValue(ref StringBuilder value) { long curline = lines + 1; if (value.Length == 0 || value.ToString().ToUpper() == globals.nullstr) { if (globals.Columns[curcol].Nullable == true) { return(true); } else { return(false); } } switch (globals.Columns[curcol].Type) { case "char": case "nchar": case "varchar": case "nvarchar": if (globals.Columns[curcol].Length != -1 && value.Length > globals.Columns[curcol].Length) { return(OutputValueErrMsg(ref value, "String truncation", "\0x1A")); } break; case "int": try { SqlInt32 i = SqlInt32.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "-28")); } break; case "bigint": try { SqlInt64 i = SqlInt64.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "-28")); } break; case "tinyint": try { SqlByte i = SqlByte.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "28")); } break; case "smallint": try { SqlInt16 i = SqlInt16.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "-28")); } break; case "numeric": case "decimal": try { // SqlDecimal d = SqlDecimal.Parse(value.ToString()); // for very large values this may work, while .Net decimal overflows decimal d = decimal.Parse(value.ToString()); // the DataTable uses .Net types, so overflows will cause exceptions in outer loop } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "-28.28")); } break; case "float": case "real": try { SqlSingle s = SqlSingle.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "-28.28")); } break; case "datetime": case "datetime2": case "smalldatetime": try { if (Convert.ToInt32(value.ToString().Substring(0, 4)) < (globals.Columns[curcol].Type == "datetime" ? 1753 : (globals.Columns[curcol].Type == "datetime2" ? 1 : 1900))) { return(OutputValueErrMsg(ref value, "Year value is too small", null)); } int dot = value.ToString().IndexOf("."); if (dot > 0) // fractional seconds given? { if (globals.Columns[curcol].Type == "smalldatetime") // strip fractional seconds off smalldatetime { string tmp = value.ToString(); value.Clear(); value.Append(tmp.Substring(0, tmp.IndexOf('.'))); } else { if (value.Length - dot > 3) { string tmp = value.ToString(); value.Clear(); value.Append(tmp.Substring(0, dot + 3)); // limitation here is .NET datetime - in theory this could be a datetime2(1), which would fail... } } } SqlDateTime dt = SqlDateTime.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, null)); } break; case "date": case "time": try { DateTime d = DateTime.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, null)); } break; case "uniqueidentifier": try { SqlGuid u = SqlGuid.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "00000000-0000-0000-0000-000000000000")); } break; case "bit": try { SqlBoolean u = SqlBoolean.Parse(value.ToString()); } catch (Exception e) { return(OutputValueErrMsg(ref value, e.Message, "0")); } break; } return(true); }
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 static SqlBoolean InitMethod([SqlFacet(MaxSize = -1)] SqlString sqlDataValue, SqlString sqlDataType) { String dataValue = sqlDataValue.ToString().Trim(); String dataType = sqlDataType.ToString().Trim(); GroupCollection typeGroups = splitType.Match(dataType).Groups; String typeText = typeGroups["type"].Value; String typePrecision = typeGroups["precision"].Value; String typeScale = typeGroups["scale"].Value; try { switch (typeText.ToLower()) { case "bit": SqlBoolean.Parse(dataValue); break; case "tinyint": SqlByte.Parse(dataValue); break; case "smallint": SqlInt16.Parse(dataValue); break; case "int": SqlInt32.Parse(dataValue); break; case "bigint": SqlInt64.Parse(dataValue); break; case "smallmoney": if (NumberOfDecimals(dataValue) > 4) { throw new OverflowException(); } SqlMoney smallmoneyValue = SqlMoney.Parse(dataValue); if (SqlMoney.LessThan(smallmoneyValue, smallmoneyMinValue) || SqlMoney.GreaterThan(smallmoneyValue, smallmoneyMaxValue)) { throw new OverflowException(); } break; case "money": if (NumberOfDecimals(dataValue) > 4) { throw new OverflowException(); } SqlMoney.Parse(dataValue); break; case "decimal": case "numeric": if (NumberOfDecimals(dataValue) > Convert.ToInt32(typeScale)) { throw new OverflowException(); } SqlDecimal.Parse(dataValue); break; case "real": SqlSingle singleValue = SqlSingle.Parse(dataValue); if (singleValue.ToString().Length != dataValue.Length + (NumberOfWholes(dataValue) == 0 ? 1 : 0)) { throw new OverflowException(); } break; case "float": SqlDouble doubleValue = SqlDouble.Parse(dataValue); if (doubleValue.ToString().Length != dataValue.Length + (NumberOfWholes(dataValue) == 0 ? 1 : 0)) { throw new OverflowException(); } break; case "date": case "datetime": case "datetime2": SqlDateTime.Parse(dataValue); break; case "char": case "varchar": case "nchar": case "nvarchar": if (typePrecision != "max" && dataValue.Length > Convert.ToInt32(typePrecision)) { throw new OverflowException(); } break; case "uniqueidentifier": SqlGuid.Parse(dataValue); break; case "geometry": SqlGeometry.Parse(dataValue); break; case "geography": SqlGeography.Parse(dataValue); break; // we do not handle these at this time case "xml": case "time": case "datetimeoffset": case "hierarchyid": case "image": case "text": case "ntext": case "rowversion": case "sql_variant": case "table": case "timestamp": case "varbinary": default: break; } return(SqlBoolean.True); } catch { return(SqlBoolean.False); } }