public static string GetVariableType(DbType dbType, bool isNullableColumn) { string variableType = GetVariableType(dbType); if (isNullableColumn && Utility.IsNullableDbType(dbType)) variableType = variableType + "?"; return variableType; }
/// <summary> /// 将C#值转成数据库能存储的值 /// </summary> /// <param name="valu"></param> /// <param name="type"></param> /// <returns></returns> public object ParamConvertValue(object valu, DbType type) { if (valu == null) { return null; } // 时间类型转换 if (type == DbType.DateTime) { DateTime dtValue; DateTime.TryParse(valu.ToString(), out dtValue); if (dtValue == DateTime.MinValue) { valu = new DateTime(1900, 1, 1); } } // 枚举类型转换 if (valu is Enum) { valu = Convert.ToInt32(valu); } // List类型转换成字符串并以,分隔 if (valu.GetType().IsGenericType) { var sb = new StringBuilder(); // list类型 if (valu.GetType().GetGenericTypeDefinition() != typeof(Nullable<>)) { var enumerator = ((IEnumerable)valu).GetEnumerator(); while (enumerator.MoveNext()) { sb.Append(enumerator.Current + ","); } } else { if (valu.GetType().GetGenericArguments()[0] == typeof(int)) { var enumerator = ((IEnumerable<int?>)valu).GetEnumerator(); while (enumerator.MoveNext()) { sb.Append(enumerator.Current.GetValueOrDefault() + ","); } } } valu = sb.Length > 0 ? sb.Remove(sb.Length - 1, 1).ToString() : ""; } return valu; }
public string DbTypeToString(DbType type, int? length) { string ret; if (TypesAsStrings.TryGetValue(type, out ret)) return ret; throw new NotImplementedException(Enum.GetName(typeof(DbType), type)); }
private static string GetVariableType(DbType dbType) { switch (dbType) { case DbType.AnsiString: case DbType.AnsiStringFixedLength: case DbType.String: case DbType.StringFixedLength: return "string"; case DbType.Binary: return "byte[]"; case DbType.Boolean: return "bool"; case DbType.Byte: return "byte"; case DbType.Currency: case DbType.Decimal: case DbType.VarNumeric: return "decimal"; case DbType.Date: case DbType.DateTime: return "DateTime"; case DbType.Double: return "double"; case DbType.Guid: return "Guid"; case DbType.Int16: return "short"; case DbType.Int32: return "int"; case DbType.Int64: return "long"; case DbType.Object: return "object"; case DbType.SByte: return "sbyte"; case DbType.Single: return "float"; case DbType.Time: return "TimeSpan"; case DbType.UInt16: return "ushort"; case DbType.UInt32: return "uint"; case DbType.UInt64: return "ulong"; default: return "string"; } }
protected CouchBase(string username, string password, AuthenticationType aT, DbType dbType) { this.username = username; this.password = password; this.authType = aT; this.dbType = dbType; }
public virtual DbParameter AddParameter(DbCommand dm, string name, DbType dbType, int size, ParameterDirection direction, bool nullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value) { ////if (dbType == DbType.String) //// throw new Exception("请不要使用DbType.String进行数据库查询!"); if (CheckInjectAttackForSp(dm, value)) throw new Exception("输入的部分内容可能对系统稳定性造成影响,操作已停止![" + value + "]"); DbParameter param = this.ProviderFactory.CreateParameter(); if (param != null) { param.ParameterName = name; param.DbType = dbType; param.Size = size; param.Value = value ?? DBNull.Value; param.Direction = direction; param.IsNullable = nullable; param.SourceColumn = sourceColumn; param.SourceVersion = sourceVersion; dm.Parameters.Add(param); } return param; }
public static bool ContainsRule(Csla.Core.BusinessBase obj, DbType type, string propertyName) { switch (type) { case DbType.Int16: case DbType.Int32: case DbType.Int64: return obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.integerrequired/{0}", propertyName)) || obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://csla.rules.commonrules.dataannotation/{0}?a=Epiworx.Core.Validation.IntegerRequiredAttribute", propertyName)); case DbType.Decimal: return obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.decimalrequired/{0}", propertyName)); case DbType.Date: return obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.daterequired/{0}", propertyName)); case DbType.DateTime: return obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.datetimerequired/{0}", propertyName)); case DbType.String: case DbType.StringFixedLength: return obj.BrokenRulesCollection.Any( brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.stringrequired/{0}", propertyName)); default: throw new NotSupportedException(); } }
/// <summary> /// Initialises a new instance of the <see cref="ColumnInfo"/> class. /// </summary> /// <param name="columnName">The name of the column in the database table.</param> /// <param name="dbType">The <see cref="DbType"/> of the column in the database table.</param> /// <param name="propertyInfo">The property info for the property the column maps to.</param> /// <param name="isIdentifier">A value indicating whether column is the table identifier column (primary key).</param> /// <param name="allowInsert">true if the column can be inserted, otherwise false.</param> /// <param name="allowUpdate">true if the column can be updated, otherwise false.</param> /// <param name="sequenceName">The name of the sequence which generates the identifier value or null if sequences are not used.</param> /// <exception cref="ArgumentNullException">Thrown if columnName or propertyInfo are null.</exception> public ColumnInfo( string columnName, DbType dbType, PropertyInfo propertyInfo, bool isIdentifier, bool allowInsert, bool allowUpdate, string sequenceName) { if (columnName == null) { throw new ArgumentNullException("columnName"); } if (propertyInfo == null) { throw new ArgumentNullException("propertyInfo"); } this.columnName = columnName; this.dbType = dbType; this.propertyInfo = propertyInfo; this.isIdentifier = isIdentifier; this.allowInsert = allowInsert; this.allowUpdate = allowUpdate; this.sequenceName = sequenceName; }
protected override string TypeName(DbType type) { switch (type) { case DbType.Binary: return "bit"; case DbType.Boolean: return "smallint unsigned"; case DbType.Byte: return "smallint unsigned"; case DbType.DateTime: case DbType.DateTime2: return "timestamp"; case DbType.DateTimeOffset: return "timestamptz"; case DbType.Double: return "double precision"; default: return base.TypeName(type); } }
public EntityParameter(string parameterName, DbType dbType, int size, string sourceColumn) { SetParameterNameWithValidation(parameterName, "parameterName"); DbType = dbType; Size = size; SourceColumn = sourceColumn; }
/// <summary> /// Constructs a VarArgsSQLFunction instance with a 'static' return type. An example of a 'static' /// return type would be something like an <code>UPPER</code> function which is always returning /// a SQL VARCHAR and thus a string type. /// </summary> /// <param name="registeredType">the return type</param> /// <param name="begin">the beginning of the function templating</param> /// <param name="sep">the separator for each individual function argument</param> /// <param name="end">the end of the function templating</param> public VarArgsSQLFunction(DbType registeredType, String begin, String sep, String end) { this.registeredType = registeredType; this.begin = begin; this.sep = sep; this.end = end; }
public void CreateAndCacheDbCommandParameters(string sqlCommandText, DbCommand command, string[] paramNames, DbType[] paramDbTypes, object[] paramValues) { lock (lockObject) { if (this.ParameterCache.IsCache(sqlCommandText)) { this.ParameterCache.AddParametersFromCache(sqlCommandText, command, paramDbTypes, paramValues); } else { if (this.ParameterCache.IsCache(sqlCommandText)) { this.ParameterCache.AddParametersFromCache(sqlCommandText, command, paramDbTypes, paramValues); } else { this.ParameterCache.CreateAndCacheParameters(sqlCommandText, command, paramNames, paramDbTypes, paramValues); } } } }
public DBMapping(string first, string second, DbType type, int size) { this._first = first; this._second = second; this._type = type; this._size = size; }
public Parameters(string Name, object Value, ParameterDirection Direction) { ParamName = Name; ParamValue = Value; ParamDbType = DbType.Object; ParamDirection = Direction; }
public Parameters(string Name, object Value,DbType dbType) { ParamName = Name; ParamValue = Value; ParamDbType = dbType; ParamDirection = ParameterDirection.Input; }
public Parameter(String parameterName, DbType dbtype) { _parameterName = parameterName; _value = DBNull.Value; _dbType = dbtype; _sourceVersion = DataRowVersion.Default; }
public static void AreEqual(string parameterName, object value, DbType dbType, SqlParameter actual) { Assert.IsNotNull(actual, "Parameter should not be null."); Assert.AreEqual(parameterName, actual.ParameterName, "ParameterName"); Assert.AreEqual(value, actual.Value, "Value"); Assert.AreEqual(dbType, actual.DbType, "DbType"); }
public SqlParameter(SqlStatement sqlStatement, object value, DbType dbType, string name) { this.Parent = sqlStatement ; this.value = value; this.dbType = dbType; this.name = name; }
public FakeDataParameter(DbType dbType, string parameterName, object value) : this(dbType, ParameterDirection.Input, true, null, null, DataRowVersion.Current, value) { }
public void Add(string name, DbType type) { DbParameter parameter = Command.CreateParameter(); parameter.ParameterName = string.Format("{0}{1}", ParameterPrefix, name); parameter.DbType = type; Command.Parameters.Add(parameter); }
public DbParameterHelper(DbType type, string name, object value, ParameterDirection direction) { DbType = type; Name = name; Value = value; Direction = direction; }
internal static void TryDetermineSubQueryDataType(SelectStatement query, out Type dataType, out DbType dbType) { // Automatically determine data type if possible. if (query.SelectList.Count == 1) { SelectItem firstItem = query.SelectList[0]; if (firstItem.ItemType == SqlItemType.Column) { IDbColumn field = (IDbColumn)firstItem.Item; dataType = field.DataType; dbType = field.DbType; } else if (firstItem.ItemType == SqlItemType.Function) { Function function = (Function)firstItem.Item; dataType = function.DataType; dbType = function.DbType; } else { dataType = typeof(object); dbType = DbType.Object; } } else { dataType = typeof(object); dbType = DbType.Object; } }
public static void CreateParameter(this IDbCommand command, string name, DbType dbType) { IDbDataParameter parameter = command.CreateParameter(); parameter.ParameterName = name; parameter.DbType = dbType; command.Parameters.Add(parameter); }
/// <summary> /// Extension for adding single parameter /// </summary> public static void AddParam(this DbCommand cmd, object item, DbType? type = null) { var p = cmd.CreateParameter(); p.ParameterName = string.Format("@{0}", cmd.Parameters.Count); if (item == null) { p.Value = DBNull.Value; } else { if (item.GetType() == typeof(Guid)) { p.Value = item.ToString(); p.DbType = DbType.String; p.Size = 4000; } else if (item.GetType() == typeof(ExpandoObject)) { var d = (IDictionary<string, object>)item; p.Value = d.Values.FirstOrDefault(); } else { p.Value = item; if (type.HasValue) p.DbType = type.Value; } if (item.GetType() == typeof(string)) p.Size = ((string)item).Length > 4000 ? -1 : 4000; } cmd.Parameters.Add(p); }
public Column(string name, DbType type) { ColumnName = name; IsAutoIncrement = false; Type = type; IsNullable = true; }
public ExtendedProperty(string name, object value, DbType dataType, PropertyStateEnum state) { this.name = name; this.value = value; this.dataType = dataType; this.propertyState = state; }
protected override IDataParameter GetParameter(string name, object paramValue, DbType datatype) { object value = paramValue; DbType localDatatype = datatype; if (datatype == DbType.Guid) localDatatype = DbType.String; else localDatatype = datatype; NpgsqlParameter param; if (datatype == DbType.Guid && value != DBNull.Value) { value = new Guid(paramValue.ToString()); param = new NpgsqlParameter(name, localDatatype); param.Value = value; } else { param = new NpgsqlParameter(name, value); param.DbType = localDatatype; } return param; }
public RelationalTypeMapping([NotNull] string defaultTypeName, DbType? storeType = null) { Check.NotEmpty(defaultTypeName, nameof(defaultTypeName)); DefaultTypeName = defaultTypeName; StoreType = storeType; }
public ExtendedProperty(string name, object value, DbType dataType) { this.name = name; this.value = value; this.dataType = dataType; this.propertyState = PropertyStateEnum.Unmodified; }
public DbParameter CreateParameter(Type connectionType, string sourceColumn, ParameterDirection parameterDirection, DbType parameterDbType, int parameterSize, byte parameterPrecision, byte parameterScale, bool parameterNullable, string parameterName, object parameterValue) { DbParameter dbParameter; if ((object)connectionType == null) throw new ArgumentNullException(nameof(connectionType)); using (DbConnection dbConnection = (DbConnection)Activator.CreateInstance(connectionType)) { using (DbCommand dbCommand = dbConnection.CreateCommand()) dbParameter = dbCommand.CreateParameter(); dbParameter.ParameterName = parameterName; dbParameter.Size = parameterSize; dbParameter.Value = parameterValue; dbParameter.Direction = parameterDirection; dbParameter.DbType = parameterDbType; this.ReflectionFascade.SetLogicalPropertyValue(dbParameter, "IsNullable", parameterNullable, true, false); dbParameter.Precision = parameterPrecision; dbParameter.Scale = parameterScale; dbParameter.SourceColumn = sourceColumn; return dbParameter; } }
public static IFullNodeBuilder UsePosConsensus(this IFullNodeBuilder fullNodeBuilder, DbType coindbType = DbType.Rocksdb) { LoggingConfiguration.RegisterFeatureNamespace <PosConsensusFeature>("posconsensus"); fullNodeBuilder.ConfigureFeature(features => { features .AddFeature <PosConsensusFeature>() .FeatureServices(services => { AddCoindbImplementation(services, coindbType); services.AddSingleton <IStakdb>(provider => (IStakdb)provider.GetService <ICoindb>()); services.AddSingleton <ICoinView, CachedCoinView>(); services.AddSingleton <StakeChainStore>().AddSingleton <IStakeChain, StakeChainStore>(provider => provider.GetService <StakeChainStore>()); services.AddSingleton <IStakeValidator, StakeValidator>(); services.AddSingleton <IRewindDataIndexCache, RewindDataIndexCache>(); services.AddSingleton <IConsensusRuleEngine, PosConsensusRuleEngine>(); services.AddSingleton <IChainState, ChainState>(); services.AddSingleton <ConsensusQuery>() .AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>()) .AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>()); services.AddSingleton <IProvenBlockHeaderStore, ProvenBlockHeaderStore>(); services.AddSingleton <IProvenBlockHeaderRepository, ProvenBlockHeaderRepository>(); }); }); return(fullNodeBuilder); }
public abstract void AddParameter(IDbCommand command, string paramName, DbType type);
public abstract void AddParameterWithValue(IDbCommand command, string paramName, DbType type, ParameterDirection direction, object value);
public CsqCommonFunction(BQLValueItem[] values, DelCommonFunction funHandle, DbType dbType) { this.funHandle = funHandle; this.values = values; this._valueDbType = dbType; }
internal static ArgumentException DbTypeNotSupported(DbType type, Type enumtype) { return(Argument(SR.GetString(SR.ADP_DbTypeNotSupported, type.ToString(), enumtype.Name))); }
public static SQLiteParameter AddSqlParm(string ParmName, object Value, DbType Sqltype) { return(AddSqlParm(ParmName, Value, Sqltype, -1)); }
IAlteredColumn IExistingColumn.AlterToNotNullable(DbType dbType) { _command.Add(new AlterColumnDefinitionCommand(_command, dbType, false)); return(this); }
/// <summary> /// Look up a DbType from a .Net type. /// </summary> /// <param name="type">The type of object to look up.</param> /// <param name="serializer">The serializer that has been detected for the field.</param> /// <param name="parameterType">The expected sql parameter type. Used as the default.</param> /// <returns>The equivalent DbType.</returns> private static DbType LookupDbType(Type type, IDbObjectSerializer serializer, DbType parameterType) { DbType sqlType; // if the serializer can serialize it, then it's a string if (serializer != null && serializer.CanSerialize(type, parameterType)) { return(serializer.GetSerializedDbType(type, parameterType)); } // if the type is nullable, get the underlying type var nullUnderlyingType = Nullable.GetUnderlyingType(type); if (nullUnderlyingType != null) { type = nullUnderlyingType; } // if it's an enum, get the underlying type if (type.GetTypeInfo().IsEnum) { type = Enum.GetUnderlyingType(type); } // look up the type if (_typeToDbTypeMap.TryGetValue(type, out sqlType)) { return(sqlType); } // special cases for XmlDocument and XDocument if (type == typeof(XmlDocument)) { return(DbType.Xml); } if (type == typeof(XDocument)) { return(DbType.Xml); } // support for enumerables if (typeof(IEnumerable).IsAssignableFrom(type)) { // use -1 to denote its a list, hacky but will work on any DB return(DbTypeEnumerable); } // sql udts are udts if (TypeHelper.IsSqlUserDefinedType(type)) { return(DbType.Object); } // let's see if the type can be directly converted to the parameter type return(parameterType); }
private static Action <IDbCommand, object> CreateClassInputParameterGenerator(IDbCommand command, Type type) { var provider = InsightDbProvider.For(command); var parameters = provider.DeriveParameters(command); // special case if the parameters object is an IEnumerable or Array // look for the parameter that is a Structured object and pass the array to the TVP // note that string supports ienumerable, so exclude atomic types var enumerable = type.GetInterfaces().FirstOrDefault(i => i.GetTypeInfo().IsGenericType&& i.GetGenericTypeDefinition() == typeof(IEnumerable <>)); if (enumerable != null && type != typeof(string) && parameters.OfType <IDataParameter>().Where(p => p.Direction.HasFlag(ParameterDirection.Input)).Count() == 1) { return((IDbCommand cmd, object o) => { // don't use the provider above. The command may be unwrapped by the time we get back here var tableParameter = InsightDbProvider.For(cmd).CloneParameter(cmd, parameters.OfType <IDataParameter>().Single(p => p.Direction.HasFlag(ParameterDirection.Input))); cmd.Parameters.Add(tableParameter); ListParameterHelper.ConvertListParameter(tableParameter, o, cmd); }); } // get the mapping of the properties for the type var mappings = ColumnMapping.MapParameters(type, command, parameters); // start creating a dynamic method Type typeOwner = type.HasElementType ? type.GetElementType() : type; var dm = new DynamicMethod(String.Format(CultureInfo.InvariantCulture, "CreateInputParameters-{0}", Guid.NewGuid()), null, new[] { typeof(IDbCommand), typeof(object) }, typeOwner, true); var il = dm.GetILGenerator(); // copy the parameters into the command object var parametersLocal = il.DeclareLocal(typeof(IDataParameter[])); StaticFieldStorage.EmitLoad(il, provider); il.Emit(OpCodes.Ldarg_0); StaticFieldStorage.EmitLoad(il, parameters); il.Emit(OpCodes.Call, typeof(InsightDbProvider).GetMethod("CopyParameters", BindingFlags.NonPublic | BindingFlags.Instance)); il.Emit(OpCodes.Stloc, parametersLocal); // go through all of the mappings for (int i = 0; i < mappings.Count; i++) { var mapping = mappings[i]; var dbParameter = parameters[i]; // if there is no mapping for the parameter if (mapping == null) { // sql will silently eat table parameters that are not specified, and that can be difficult to debug if (provider.IsTableValuedParameter(command, dbParameter)) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Table parameter {0} must be specified", dbParameter.ParameterName)); } // unspecified input parameters get skipped if (dbParameter.Direction == ParameterDirection.Input) { parameters[i] = null; } continue; } var memberType = mapping.Member.MemberType; var serializer = mapping.Serializer; // get the parameter il.Emit(OpCodes.Ldloc, parametersLocal); il.Emit(OpCodes.Ldc_I4, i); il.Emit(OpCodes.Ldelem, typeof(IDataParameter)); // look up the best type to use for the parameter DbType sqlType = LookupDbType(memberType, serializer, dbParameter.DbType); // give the provider an opportunity to fix up the template parameter (e.g. set UDT type names) provider.FixupParameter(command, dbParameter, sqlType, memberType, mapping.Member.SerializationMode); // give a chance to override the best guess parameter DbType overriddenSqlType = ColumnMapping.MapParameterDataType(memberType, command, dbParameter, sqlType); /////////////////////////////////////////////////////////////// // We have a parameter, start handling all of the other types /////////////////////////////////////////////////////////////// if (overriddenSqlType != sqlType) { sqlType = overriddenSqlType; dbParameter.DbType = sqlType; } /////////////////////////////////////////////////////////////// // Get the value from the object onto the stack /////////////////////////////////////////////////////////////// il.Emit(OpCodes.Ldarg_1); if (type.GetTypeInfo().IsValueType) { il.Emit(OpCodes.Unbox_Any, type); } /////////////////////////////////////////////////////////////// // Special case support for enumerables. If the type is -1 (our workaround, then call the list parameter method) /////////////////////////////////////////////////////////////// if (sqlType == DbTypeEnumerable) { // we have the parameter and the value as object, add the command ClassPropInfo.EmitGetValue(type, mapping.PathToMember, il); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Call, typeof(ListParameterHelper).GetMethod("ConvertListParameter", BindingFlags.Static | BindingFlags.NonPublic)); continue; } Label readyToSetLabel = il.DefineLabel(); ClassPropInfo.EmitGetValue(type, mapping.PathToMember, il, readyToSetLabel); // special conversions for timespan to datetime if ((sqlType == DbType.Time && dbParameter.DbType != DbType.Time) || (dbParameter.DbType == DbType.DateTime || dbParameter.DbType == DbType.DateTime2 || dbParameter.DbType == DbType.DateTimeOffset)) { IlHelper.EmitLdInt32(il, (int)dbParameter.DbType); il.Emit(OpCodes.Call, typeof(TypeConverterGenerator).GetMethod("ObjectToSqlDateTime")); } // if it's class type, boxed value type (in an object), or nullable, then we have to check for null if (!memberType.GetTypeInfo().IsValueType || Nullable.GetUnderlyingType(memberType) != null) { Label notNull = il.DefineLabel(); // check to see if it's not null il.Emit(OpCodes.Dup); il.Emit(OpCodes.Brtrue, notNull); // it's null. replace the value with DbNull il.Emit(OpCodes.Pop); il.Emit(OpCodes.Ldsfld, _dbNullValue); // value is set to null. ready to set the property. il.Emit(OpCodes.Br, readyToSetLabel); // we know the value is not null il.MarkLabel(notNull); } /////////////////////////////////////////////////////////////// // if this is a linq binary, convert it to a byte array /////////////////////////////////////////////////////////////// if (memberType == TypeHelper.LinqBinaryType) { il.Emit(OpCodes.Callvirt, TypeHelper.LinqBinaryToArray); } else if (memberType == typeof(XmlDocument)) { // we are sending up an XmlDocument. ToString just returns the classname, so use the outerxml. il.Emit(OpCodes.Callvirt, memberType.GetProperty("OuterXml").GetGetMethod()); } else if (memberType == typeof(XDocument)) { // we are sending up an XDocument. Use ToString. il.Emit(OpCodes.Callvirt, memberType.GetMethod("ToString", new Type[] { })); } else if (serializer != null && serializer.CanSerialize(memberType, sqlType)) { il.EmitLoadType(memberType); StaticFieldStorage.EmitLoad(il, serializer); il.Emit(OpCodes.Call, typeof(DbParameterGenerator).GetMethod("SerializeParameterValue", BindingFlags.NonPublic | BindingFlags.Static)); } /////////////////////////////////////////////////////////////// // p.Value = value /////////////////////////////////////////////////////////////// // push parameter is at top of method // value is above il.MarkLabel(readyToSetLabel); if (memberType == typeof(string)) { il.Emit(OpCodes.Call, typeof(DbParameterGenerator).GetMethod("SetParameterStringValue", BindingFlags.NonPublic | BindingFlags.Static)); } else if ((memberType == typeof(Guid?) || (memberType == typeof(Guid))) && dbParameter.DbType != DbType.Guid && command.CommandType == CommandType.StoredProcedure) { il.Emit(OpCodes.Call, typeof(DbParameterGenerator).GetMethod("SetParameterGuidValue", BindingFlags.NonPublic | BindingFlags.Static)); } else { il.Emit(OpCodes.Callvirt, _iDataParameterSetValue); } } il.Emit(OpCodes.Ret); return((Action <IDbCommand, object>)dm.CreateDelegate(typeof(Action <IDbCommand, object>))); }
public static IFullNodeBuilder UsePowConsensus(this IFullNodeBuilder fullNodeBuilder, DbType coindbType = DbType.Rocksdb) { LoggingConfiguration.RegisterFeatureNamespace <PowConsensusFeature>("powconsensus"); fullNodeBuilder.ConfigureFeature(features => { features .AddFeature <PowConsensusFeature>() .FeatureServices(services => { AddCoindbImplementation(services, coindbType); services.AddSingleton <ConsensusOptions, ConsensusOptions>(); services.AddSingleton <ICoinView, CachedCoinView>(); services.AddSingleton <IConsensusRuleEngine, PowConsensusRuleEngine>(); services.AddSingleton <IChainState, ChainState>(); services.AddSingleton <ConsensusQuery>() .AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>()) .AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>()); }); }); return(fullNodeBuilder); }
protected SqlParameter CreateSqlParameter(string parameterName, object value, DbType dbType, ParameterDirection direction = ParameterDirection.Input) { return(new SqlParameter(parameterName, value ?? DBNull.Value) { Direction = direction, DbType = dbType }); }
/// <summary> /// Create a parameter generator for a dynamic object. /// </summary> /// <param name="command">The command to parse.</param> /// <returns>An action that fills in the command parameters from a dynamic object.</returns> private static Action <IDbCommand, object> CreateDynamicInputParameterGenerator(IDbCommand command) { var provider = InsightDbProvider.For(command); var parameters = provider.DeriveParameters(command); return((cmd, o) => { // make sure that we have a dictionary implementation IDictionary <string, object> dyn = o as IDictionary <string, object>; if (dyn == null) { throw new InvalidOperationException("Dynamic object must support IDictionary<string, object>."); } foreach (var template in parameters) { var p = provider.CloneParameter(cmd, template); // get the value from the object, converting null to db null // note that if the dictionary does not have the value, we leave the value null and then the parameter gets defaulted object value = null; if (dyn.TryGetValue(p.ParameterName, out value)) { if (value == null) { value = DBNull.Value; } else { DbType sqlType = LookupDbType(value.GetType(), null, p.DbType); if (sqlType == DbTypeEnumerable) { cmd.Parameters.Add(p); ListParameterHelper.ConvertListParameter(p, value, cmd); continue; } } } p.Value = value; // if it's a string, fill in the length IDbDataParameter dbDataParameter = p as IDbDataParameter; if (dbDataParameter != null) { string s = value as string; if (s != null) { int length = s.Length; if (length > 4000) { length = -1; } dbDataParameter.Size = length; } } // explicitly set the type of the parameter if (value != null && _typeToDbTypeMap.ContainsKey(value.GetType())) { dbDataParameter.DbType = _typeToDbTypeMap[value.GetType()]; } cmd.Parameters.Add(p); } }); }
public SqlParameter(string parameterName, DbType dataType, string parameterValue) : this(parameterName, dataType, parameterValue, ParameterDirection.Input) { }
public string CreateSelectSql(DbType dbType, ValueKind kind) => SqlServerDatabase.CreateSelectSql(dbType, kind);
/// <summary> /// Get the datastore MaxLength for DbParameter /// </summary> public abstract Int32 GetMaxLengthFromDbType(DbType dbType, Int32 maxLength);
/// <summary> /// 功能描述:设置初始化参数 /// 作 者:LX_Core /// </summary> /// <param name="strConnectionString">连接字符串</param> /// <param name="enmDbType">数据库类型</param> public static void Init(string strConnectionString, DbType enmDbType = SqlSugar.DbType.SqlServer) { _connectionString = strConnectionString; _dbType = enmDbType; }
/// <summary> /// Get the datastore precision / scale / length string for generating scripts /// </summary> public abstract string GetPrecisionStringFromDbType(DbType dbType, int maxLength, byte precision, byte scale);
/// <summary> /// Gets the corresponding DbType from a owner dbtype /// </summary> public abstract object GetOwnerDbTypeFromDbType(DbType dbType);
public (byte precision, byte scale) TryGetOwnerPrecisionAndScale(string originalDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, byte precision, byte scale, string fromProviderType, string ownerProviderType) { // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype if (!String.IsNullOrEmpty(originalDbType) && fromProviderType == ownerProviderType) { SqlDbType sqlDbType = (SqlDbType)ValidateOwnerDbType(originalDbType, isUnsigned, isUnicode); return(GetPrecisionFromOwnerDbType(sqlDbType, precision, scale)); } // if it's not the same provider, fallback on DbType instead. return(GetPrecisionFromDbType(fallbackDbType, precision, scale)); }
/// <summary> /// Get the datastore precision / scale for DbParameter /// </summary> public abstract (byte precision, byte scale) GetPrecisionFromDbType(DbType dbType, byte precision, byte scale);
/// <summary> /// Determine the data type based on the value /// </summary> private void InferType() { if (Value == null) { throw new ArgumentException("No DB2Parameter.Value found"); } if (Value is IConvertible) { switch (((IConvertible)Value).GetTypeCode()) { case TypeCode.Char: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_WCHAR; break; case TypeCode.Boolean: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_BIT; break; case TypeCode.SByte: case TypeCode.Byte: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break; case TypeCode.UInt16: case TypeCode.Int16: dbType = DbType.Int16; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break; case TypeCode.UInt32: case TypeCode.Int32: dbType = DbType.Int32; db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break; case TypeCode.UInt64: case TypeCode.Int64: dbType = DbType.Int64; db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break; case TypeCode.Single: dbType = DbType.Single; db2Type = DB2Type.Float; db2DataType = DB2Constants.SQL_REAL; break; case TypeCode.Double: dbType = DbType.Double; db2Type = DB2Type.Double; db2DataType = DB2Constants.SQL_DOUBLE; break; case TypeCode.Decimal: dbType = DbType.Decimal; db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break; case TypeCode.DateTime: dbType = DbType.DateTime; db2Type = DB2Type.Timestamp; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break; case TypeCode.String: dbType = DbType.String; db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break; case TypeCode.Object: case TypeCode.DBNull: case TypeCode.Empty: throw new SystemException("Unknown data type"); default: throw new SystemException("Value is of unknown data type"); } } else if (Value is byte[]) { dbType = DbType.Binary; db2Type = DB2Type.VarBinary; db2DataType = DB2Constants.SQL_VARBINARY; } else if (Value is TimeSpan) { dbType = DbType.Time; db2Type = DB2Type.Time; db2DataType = DB2Constants.SQL_TYPE_TIME; } else { throw new NotSupportedException("Value is of unsupported data type"); } }
/// <summary> /// Get the datastore type name from a DbType for generating scripts /// </summary> public abstract string GetStringFromDbType(DbType dbType);
public static IDbDataParameter CreateParameter(string providerName, string parameterName, object value, DbType dbType, int size = 0, ParameterDirection direction = ParameterDirection.Input) { IDbDataParameter parameter = null; switch (providerName) { case "System.Data.SqlClient": parameter = CreateSqlParameter(parameterName, value, dbType, size, direction); break; case "System.Data.OdbcClient": parameter = CreateOdbcParameter(parameterName, value, dbType, size, direction); break; default: break; } return(parameter); }
/// <inheritdoc/> public override void FixupParameter(IDbCommand command, IDataParameter parameter, DbType dbType, Type type, SerializationMode serializationMode) { if (command == null) { throw new ArgumentNullException("command"); } if (parameter == null) { throw new ArgumentNullException("parameter"); } base.FixupParameter(command, parameter, dbType, type, serializationMode); // when calling sql text, we have to fill in the udttypename for some parameters if (command.CommandType != CommandType.StoredProcedure && IsSqlUserDefinedType(type)) { SqlParameter p = (SqlParameter)parameter; p.SqlDbType = SqlDbType.Udt; #if !NO_SQL_TYPES switch (type.Name) { case "SqlGeometry": p.UdtTypeName = "sys.geometry"; break; case "SqlGeography": p.UdtTypeName = "sys.geography"; break; case "SqlHierarchy": p.UdtTypeName = "sys.hierarchyid"; break; } #endif } // older versions of SQL Server (CE and 2005) don't support DateTime2 // newer versions do, so if we have a new version and it's a datetime, make it bigger if (parameter.DbType == DbType.DateTime) { var sc = (SqlConnection)command.Connection; var version = Int32.Parse(sc.ServerVersion.Split('.')[0], CultureInfo.InvariantCulture); if (version >= 10) { parameter.DbType = DbType.DateTime2; } } }
/// <summary> /// 把数据类型转换成当前数据库支持的类型 /// </summary> /// <param name="type"></param> /// <returns></returns> public DbType ToCurrentDbType(DbType type) { return(CurrentDbType(type)); }
/// <summary> /// 把 DbType的类型值 转换为 MySql 数据库中兼容的数据类型 /// MySql数据精度 http://qimo601.iteye.com/blog/1622368 /// </summary> /// <param name="fieldType">字段的DbType类型值</param> /// <param name="length">数据类型的长度</param> /// <returns>返回MySql数据库中的具体类型值</returns> public override string ConvertToDatabaseTypeName(DbType fieldType, string length = null) { switch (fieldType) { case DbType.String: case DbType.AnsiString: if (!string.IsNullOrEmpty(length) && !string.Equals("max", length, StringComparison.CurrentCultureIgnoreCase)) { return("VARCHAR(" + length + ")"); } return("TEXT"); case DbType.Xml: return("TEXT"); case DbType.SByte: case DbType.Byte: return("TINYINT"); case DbType.UInt16: case DbType.Int16: return("SMALLINT"); case DbType.UInt32: case DbType.Int32: return("INT"); case DbType.UInt64: case DbType.Int64: return("BIGINT"); case DbType.Time: return("TIME"); case DbType.Date: return("DATE"); case DbType.DateTime: case DbType.DateTimeOffset: return("DATETIME"); case DbType.Single: return("FLOAT"); case DbType.Double: return("DOUBLE"); case DbType.Decimal: if (!string.IsNullOrWhiteSpace(length)) { return("DECIMAL(" + length + ")"); } return("DECIMAL(18,2)"); case DbType.Binary: return("BLOB"); case DbType.Boolean: return("TINYINT(1)"); //return "BIT";// Boolean 映射为 BIT 时,批量导入会出错。 default: break; } throw new NotSupportedException(string.Format("不支持生成列类型:{0}。", fieldType)); }
/// <summary> /// 把DBType类型转成对应的SQLType /// </summary> /// <param name="dbType"></param> /// <returns></returns> public virtual string DBTypeToSQL(DbType dbType, long length) { int type = ToRealDbType(dbType, length); DbType stype = (DbType)type; switch (stype) { case DbType.AnsiString: case DbType.AnsiStringFixedLength: case DbType.String: case DbType.StringFixedLength: if (length <= 255) { return("Text(" + length + ")"); } return("Memo"); case DbType.Boolean: return("YesNo"); case DbType.Byte: return("Byte"); case DbType.Currency: return("Currency"); case DbType.Date: return("Date"); case DbType.DateTime: case DbType.DateTime2: case DbType.DateTimeOffset: case DbType.Time: return("DateTime"); case DbType.Single: return("Single"); case DbType.Double: return("Double"); case DbType.SByte: case DbType.Int16: return("Integer"); case DbType.UInt16: case DbType.Int32: return("Long"); case DbType.Int64: case DbType.UInt32: case DbType.UInt64: case DbType.Decimal: case DbType.VarNumeric: return("Decimal"); case DbType.Binary: return("OLEObject"); case DbType.Guid: return("ReplicationID"); default: return(stype.ToString()); } }
/// <summary> /// 获取当前时间 /// </summary> /// <returns></returns> public string GetNowDate(DbType dbType) { return("now()"); }
public MyField(string fieldName, object fieldValue, Type type) { this._fieldName = fieldName; this._fieldValue = fieldValue; this._dataType = TableManager.TypeToDbType(type); }
/// <summary> /// 把DBType转成本数据库的实际类型 /// </summary> /// <param name="dbType"></param> /// <returns></returns> public virtual int ToRealDbType(DbType dbType, long length) { //switch (dbType) //{ // case DbType.AnsiString: // if (length < 8000) // { // return (int)OleDbType.Char; // } // else // { // return (int)OleDbType.LongVarChar; // } // case DbType.AnsiStringFixedLength: // if (length < 8000) // { // return (int)OleDbType.Char; // } // else // { // return (int)OleDbType.LongVarChar; // } // case DbType.Binary: // if (length < 8000) // { // return (int)OleDbType.Binary; // } // else // { // return (int)OleDbType.LongVarBinary; // } // case DbType.Boolean: // return (int)OleDbType.Boolean; // case DbType.Byte: // return (int)OleDbType.UnsignedTinyInt; // case DbType.Currency: // return (int)OleDbType.Currency; // case DbType.Date: // return (int)OleDbType.DBDate; // case DbType.DateTime: // case DbType.DateTime2: // case DbType.DateTimeOffset: // return (int)OleDbType.DBTimeStamp; // case DbType.Time: // return (int)OleDbType.DBTime; // case DbType.Decimal: // return (int)OleDbType.Decimal; // case DbType.Double: // return (int)OleDbType.Double; // case DbType.Guid: // return (int)OleDbType.Guid; // case DbType.Int16: // return (int)OleDbType.SmallInt; // case DbType.UInt16: // return (int)OleDbType.UnsignedSmallInt; // case DbType.Int32: // return (int)OleDbType.Integer; // case DbType.Int64: // return (int)OleDbType.BigInt; // case DbType.SByte: // return (int)OleDbType.TinyInt; // case DbType.Single: // return (int)OleDbType.Single; // case DbType.String: // if (length < 4000) // { // return (int)OleDbType.VarWChar; // } // else // { // return (int)OleDbType.LongVarWChar; // } // case DbType.StringFixedLength: // if (length < 4000) // { // return (int)OleDbType.WChar; // } // else // { // return (int)OleDbType.LongVarWChar; // } // case DbType.UInt32: // return (int)OleDbType.UnsignedInt; // case DbType.UInt64: // return (int)OleDbType.UnsignedBigInt; // case DbType.VarNumeric: // return (int)OleDbType.VarNumeric; // default: // return (int)OleDbType.PropVariant; //} return((int)dbType); }