public static NpgsqlCommand Returns(this NpgsqlCommand command, string name, NpgsqlDbType type) { var parameter = command.AddParameter(name); parameter.NpgsqlDbType = type; parameter.Direction = ParameterDirection.ReturnValue; return command; }
/// <summary> /// Find a NpgsqlNativeTypeInfo in the default types map that can handle objects /// of the given NpgsqlDbType. /// </summary> public static NpgsqlNativeTypeInfo GetNativeTypeInfo(NpgsqlDbType NpgsqlDbType) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "GetBackendTypeNameFromNpgsqlDbType"); VerifyDefaultTypesMap(); return NativeTypeMapping[NpgsqlDbType]; }
public EnumIsOneOfWhereFragment(object values, EnumStorage enumStorage, string locator) { var array = values.As<Array>(); if (enumStorage == EnumStorage.AsInteger) { var numbers = new int[array.Length]; for (int i = 0; i < array.Length; i++) { numbers[i] = array.GetValue(i).As<int>(); } _values = numbers; _dbType = NpgsqlDbType.Integer | NpgsqlDbType.Array; } else { var strings = new string[array.Length]; for (int i = 0; i < array.Length; i++) { strings[i] = array.GetValue(i).ToString(); } _values = strings; _dbType = NpgsqlDbType.Varchar | NpgsqlDbType.Array; } _locator = locator; }
public PostgresqlType(string postgresqlColumnType, string infoSchemaName, NpgsqlDbType postgresqlDbType, DbType databaseType, MungTypeCode code) { InfoSchemaName = infoSchemaName; CreateColumnDefinition = postgresqlColumnType; PostgresqlDbType = postgresqlDbType; DatabaseType = databaseType; MungType = MungType.Get(code); }
public NpgsqlParameter AddParameter(object value, NpgsqlDbType dbType) { var name = "p" + _counter++; var param = Command.AddParameter(name, value); param.NpgsqlDbType = dbType; return param; }
public SprocCall Param(string argName, object value, NpgsqlDbType dbType) { var param = _parent.AddParameter(value, dbType); _parameters.Add(new ParameterArg(argName, param)); return this; }
public static NpgsqlParameter MakeParameter(string paramName, string value, NpgsqlDbType dbType, ParameterDirection direction) { NpgsqlParameter param = new NpgsqlParameter(":" + paramName, dbType); param.Direction = direction; param.SourceColumn = paramName; param.Value = value; return param; }
public static NpgsqlCommand With(this NpgsqlCommand command, string name, object value, NpgsqlDbType dbType) { var parameter = command.CreateParameter(); parameter.ParameterName = name; parameter.Value = value ?? DBNull.Value; parameter.NpgsqlDbType = dbType; command.Parameters.Add(parameter); return command; }
/// <summary> /// Maps an Npgsql type handler to a PostgreSQL type. /// </summary> /// <param name="pgName">A PostgreSQL type name as it appears in the pg_type table.</param> /// <param name="npgsqlDbType"> /// A member of <see cref="NpgsqlDbType"/> which represents this PostgreSQL type. /// An <see cref="NpgsqlParameter"/> with <see cref="NpgsqlParameter.NpgsqlDbType"/> set to /// this value will be sent with the type handler mapped by this attribute. /// </param> /// <param name="dbTypes"> /// All members of <see cref="DbType"/> which represent this PostgreSQL type. /// An <see cref="NpgsqlParameter"/> with <see cref="NpgsqlParameter.DbType"/> set to /// one of these values will be sent with the type handler mapped by this attribute. /// </param> /// <param name="clrTypes"> /// Any .NET type which corresponds to this PostgreSQL type. /// An <see cref="NpgsqlParameter"/> with <see cref="NpgsqlParameter.Value"/> set to /// one of these values will be sent with the type handler mapped by this attribute. /// </param> /// <param name="inferredDbType"> /// The "primary" <see cref="DbType"/> which best corresponds to this PostgreSQL type. /// When <see cref="NpgsqlParameter.NpgsqlDbType"/> or <see cref="NpgsqlParameter.Value"/> /// set, <see cref="NpgsqlParameter.DbType"/> will be set to this value. /// </param> internal TypeMappingAttribute(string pgName, NpgsqlDbType? npgsqlDbType, [CanBeNull] DbType[] dbTypes, [CanBeNull] Type[] clrTypes, DbType? inferredDbType) { if (String.IsNullOrWhiteSpace(pgName)) throw new ArgumentException("pgName can't be empty", nameof(pgName)); Contract.EndContractBlock(); PgName = pgName; NpgsqlDbType = npgsqlDbType; DbTypes = dbTypes ?? new DbType[0]; ClrTypes = clrTypes ?? new Type[0]; InferredDbType = inferredDbType; }
/// <summary> /// Adds parameter to Sql Command. /// </summary> /// <param name="name">Parameter name.</param> /// <param name="dbType">Parameter datatype.</param> /// <param name="value">Parameter value.</param> public void AddParameter(string name,NpgsqlDbType dbType,object value) { /* SqlDbType dbTyp = dbType; object val = value; if(dbType == SqlDbType.UniqueIdentifier){ dbTyp = SqlDbType.NVarChar; string guid = val.ToString(); if(guid.Length < 1){ return; } }*/ m_SqlCmd.Parameters.Add(name,dbType).Value = value; }
/// <summary> /// Construct a new NpgsqlTypeInfo with the given attributes and conversion handlers. /// </summary> /// <param name="OID">Type OID provided by the backend server.</param> /// <param name="Name">Type name provided by the backend server.</param> /// <param name="NpgsqlDbType">NpgsqlDbType</param> /// <param name="DbType">DbType</param> /// <param name="Type">System type to convert fields of this type to.</param> /// <param name="ConvertBackendTextToNative">Data conversion handler for text encoding.</param> /// <param name="ConvertBackendBinaryToNative">Data conversion handler for binary data.</param> public NpgsqlBackendTypeInfo(Int32 OID, String Name, NpgsqlDbType NpgsqlDbType, DbType DbType, Type Type, ConvertBackendTextToNativeHandler ConvertBackendTextToNative = null, ConvertBackendBinaryToNativeHandler ConvertBackendBinaryToNative = null) { if (Type == null) { throw new ArgumentNullException("Type"); } _OID = OID; _Name = Name; _NpgsqlDbType = NpgsqlDbType; _DbType = DbType; _Type = Type; _frameworkType = Type; _ConvertBackendTextToNative = ConvertBackendTextToNative; _ConvertBackendBinaryToNative = ConvertBackendBinaryToNative; }
// http://www.npgsql.org/doc/types.html private static KeyValuePair<string, bool> NpgsqlDbType2CSharpType(NpgsqlDbType npgsqlDbType) { string str; bool flag; switch (npgsqlDbType) { case NpgsqlDbType.Boolean: str = "bool"; flag = true; break; case NpgsqlDbType.Smallint: str = "short"; flag = true; break; case NpgsqlDbType.Integer: str = "int"; flag = true; break; case NpgsqlDbType.Bigint: str = "long"; flag = true; break; case NpgsqlDbType.Real: str = "float"; flag = true; break; case NpgsqlDbType.Double: str = "double"; flag = true; break; case NpgsqlDbType.Money: case NpgsqlDbType.Numeric: str = "decimal"; flag = true; break; case NpgsqlDbType.Date: case NpgsqlDbType.Timestamp: case NpgsqlDbType.TimestampTZ: case NpgsqlDbType.Abstime: str = "DateTime"; flag = true; break; case NpgsqlDbType.Time: case NpgsqlDbType.Interval: case NpgsqlDbType.TimeTZ: str = "TimeSpan"; flag = true; break; case NpgsqlDbType.Uuid: str = "Guid"; flag = false; break; case NpgsqlDbType.Bytea: case NpgsqlDbType.Bit: str = "byte[]"; flag = true; break; case NpgsqlDbType.Oidvector: str = "uint[]"; flag = true; break; case NpgsqlDbType.Array: str = "Array"; flag = false; break; case NpgsqlDbType.Char: case NpgsqlDbType.Text: case NpgsqlDbType.Varchar: case NpgsqlDbType.Inet: case NpgsqlDbType.Xml: case NpgsqlDbType.Name: case NpgsqlDbType.MacAddr: case NpgsqlDbType.Json: case NpgsqlDbType.Jsonb: case NpgsqlDbType.Hstore: str = "string"; flag = false; break; case NpgsqlDbType.Box: case NpgsqlDbType.Circle: case NpgsqlDbType.Line: case NpgsqlDbType.LSeg: case NpgsqlDbType.Path: case NpgsqlDbType.Point: case NpgsqlDbType.Polygon: case NpgsqlDbType.Refcursor: str = "object"; flag = false; break; default: str = "object"; flag = false; break; } return new KeyValuePair<string, bool>(str, flag); }
public void duplicated_field_enum_storage_should_be_taken_from_store_options_enum_storage_by_default(EnumStorage enumStorage, NpgsqlDbType expectedNpgsqlDbType) { var storeOptions = new StoreOptions(); storeOptions.UseDefaultSerialization(enumStorage); var mapping = new DocumentMapping <Target>(storeOptions); var duplicatedField = mapping.DuplicateField(nameof(Target.Color)); duplicatedField.DbType.ShouldBe(expectedNpgsqlDbType); }
public void duplicated_field_date_time_db_type_should_be_taken_from_store_options_useTimestampWithoutTimeZoneForDateTime(bool useTimestampWithoutTimeZoneForDateTime, NpgsqlDbType expectedNpgsqlDbType) { var storeOptions = new StoreOptions(); storeOptions.Advanced.DuplicatedFieldUseTimestampWithoutTimeZoneForDateTime = useTimestampWithoutTimeZoneForDateTime; var mapping = new DocumentMapping <Target>(storeOptions); var duplicatedField = mapping.DuplicateField(nameof(Target.Date)); duplicatedField.DbType.ShouldBe(expectedNpgsqlDbType); }
/// <summary> /// Reads the current column, returns its value according to <paramref name="type"/> and /// moves ahead to the next column. /// If the column is null an exception is thrown. /// </summary> /// <param name="type"> /// In some cases <typeparamref name="T"/> isn't enough to infer the data type coming in from the /// database. This parameter can be used to unambiguously specify the type. An example is the JSONB /// type, for which <typeparamref name="T"/> will be a simple string but for which /// <paramref name="type"/> must be specified as <see cref="NpgsqlDbType.Jsonb"/>. /// </param> /// <param name="cancellationToken"> /// An optional token to cancel the asynchronous operation. The default value is <see cref="CancellationToken.None"/>. /// </param> /// <typeparam name="T">The .NET type of the column to be read.</typeparam> /// <returns>The value of the column</returns> public ValueTask <T> ReadAsync <T>(NpgsqlDbType type, CancellationToken cancellationToken = default) { using (NoSynchronizationContextScope.Enter()) return(Read <T>(type, true, cancellationToken)); }
/// <summary> /// Initializes a new instance of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> /// class with the parameter m_Name, the <see cref="System.Data.DbType">DbType</see>, and the size. /// </summary> /// <param m_Name="parameterName">The m_Name of the parameter to map.</param> /// <param m_Name="parameterType">One of the <see cref="System.Data.DbType">DbType</see> values.</param> /// <param m_Name="size">The length of the parameter.</param> public NpgsqlParameter(String parameterName, NpgsqlDbType parameterType, Int32 size) : this(parameterName, parameterType, size, String.Empty) { }
public static DbType PgsqlDbType2DbType(NpgsqlDbType pgsqlDbType_in) { switch (pgsqlDbType_in) { case NpgsqlDbType.Bigint: return DbType.Int64; case NpgsqlDbType.Integer: return DbType.Int32; case NpgsqlDbType.Smallint: return DbType.Int16; case NpgsqlDbType.Boolean: return DbType.Boolean; case NpgsqlDbType.Varchar: case NpgsqlDbType.Text: return DbType.String; case NpgsqlDbType.TimestampTZ: case NpgsqlDbType.Timestamp: return DbType.DateTime; case NpgsqlDbType.Real: return DbType.Single; case NpgsqlDbType.Double: return DbType.Double; case NpgsqlDbType.Numeric: return DbType.Decimal; case NpgsqlDbType.Bytea: return DbType.Binary; case NpgsqlDbType.Date: return DbType.Date; case NpgsqlDbType.Time: return DbType.Time; case NpgsqlDbType.Money: return DbType.Decimal; #region default: throw new Exception("..."); default: { throw new Exception(string.Format( "undefined variable type: {0}", pgsqlDbType_in.ToString() )); } #endregion } }
/// <summary> /// Adds a <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> to the <see cref="Npgsql.NpgsqlParameterCollection">NpgsqlParameterCollection</see> given the specified parameter name and value. /// </summary> /// <param name="parameterName">The name of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see>.</param> /// <param name="value">The Value of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> to add to the collection.</param> /// <param name="parameterType">One of the NpgsqlDbType values.</param> /// <param name="size">The length of the column.</param> /// <param name="sourceColumn">The name of the source column.</param> /// <returns>The paramater that was added.</returns> public NpgsqlParameter AddWithValue(string parameterName, NpgsqlDbType parameterType, int size, string sourceColumn, object value) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "AddWithValue", parameterName, parameterType, size, sourceColumn, value); NpgsqlParameter param = new NpgsqlParameter(parameterName, parameterType, size, sourceColumn); param.Value = value; return this.Add(param); }
public ColumnInfo(string columnName, int columnID, DataType dataType, int lineageID, int bufferIndex, int length, int precision, int scale, string externalColumnName, NpgsqlDbType externalSqlDbType) { _columnName = columnName; _columnID = columnID; _dataType = dataType; _lineageID = lineageID; _bufferIndex = bufferIndex; _precision = precision; _scale = scale; _length = length; _externalColumnName = externalColumnName; _externalSqlDbType = externalSqlDbType; }
protected NpgsqlVarbitTypeMapping(RelationalTypeMappingParameters parameters, NpgsqlDbType npgsqlDbType) : base(parameters, npgsqlDbType) { }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType[] dbTypes, Type clrType, DbType inferredDbType) : this(pgName, npgsqlDbType, dbTypes, new[] { clrType }, inferredDbType) { }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, Type[] clrTypes) : this(pgName, npgsqlDbType, new DbType[0], clrTypes, null) { }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType dbType, Type clrType = null) : this(pgName, npgsqlDbType, new[] { dbType }, clrType == null ? null : new[] { clrType }, dbType) { }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType dbType, Type[] clrTypes) : this(pgName, npgsqlDbType, new[] { dbType }, clrTypes, dbType) { }
/// <summary> /// Initializes a new instance of the <see cref="NpgsqlParameter">NpgsqlParameter</see>. /// </summary> /// <param name="parameterName">The name of the parameter to map.</param> /// <param name="parameterType">One of the <see cref="NpgsqlTypes.NpgsqlDbType">NpgsqlDbType</see> values.</param> /// <param name="size">The length of the parameter.</param> public NpgsqlParameter(string parameterName, NpgsqlDbType parameterType, int size) : this(parameterName, parameterType, size, String.Empty) { }
void Add(string name, NpgsqlDbType type) { Command.Parameters.Add(new NpgsqlParameter(name, type)); }
void Set(NpgsqlDbType type, object value) { Enumerator.MoveNext(); Command.Parameters.Add(new NpgsqlParameter(Enumerator.Current, type)); Command.Parameters[Command.Parameters.Count - 1].Value = value; }
public ExceptionColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Text, int?columnLength = null) : base(dbType, columnLength) { }
public void InsertValue(DbType? dbType, NpgsqlDbType? npgsqlDbType, string fieldName, object value) { if (dbType.HasValue && npgsqlDbType.HasValue || (!dbType.HasValue && !npgsqlDbType.HasValue)) Assert.Fail("Exactly one of dbType and npgsqlDbType must be specified"); using (var command = new NpgsqlCommand(String.Format("INSERT INTO data ({0}) values (:a)", fieldName), Conn)) { if (dbType.HasValue) command.Parameters.Add(new NpgsqlParameter("a", dbType.Value)); else command.Parameters.Add(new NpgsqlParameter("a", npgsqlDbType.Value)); command.Parameters[0].Value = value; var rowsAdded = command.ExecuteNonQuery(); Assert.AreEqual(1, rowsAdded); } var result = ExecuteScalar(String.Format("SELECT {0} FROM data", fieldName)); Assert.AreEqual(value, result); }
public PropertiesColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Jsonb, int?columnLength = null) : base(dbType, columnLength) { }
/// <summary> /// Initializes a new instance of the <see cref="NpgsqlParameter">NpgsqlParameter</see>. /// </summary> /// <param name="parameterName">The name of the parameter to map.</param> /// <param name="parameterType">One of the <see cref="NpgsqlTypes.NpgsqlDbType">NpgsqlDbType</see> values.</param> /// <param name="size">The length of the parameter.</param> /// <param name="sourceColumn">The name of the source column.</param> /// <param name="direction">One of the <see cref="System.Data.ParameterDirection">ParameterDirection</see> values.</param> /// <param name="isNullable"><b>true</b> if the value of the field can be null, otherwise <b>false</b>.</param> /// <param name="precision">The total number of digits to the left and right of the decimal point to which /// <see cref="NpgsqlParameter.Value">Value</see> is resolved.</param> /// <param name="scale">The total number of decimal places to which /// <see cref="NpgsqlParameter.Value">Value</see> is resolved.</param> /// <param name="sourceVersion">One of the <see cref="System.Data.DataRowVersion">DataRowVersion</see> values.</param> /// <param name="value">An <see cref="System.Object">Object</see> that is the value /// of the <see cref="NpgsqlParameter">NpgsqlParameter</see>.</param> public NpgsqlParameter(string parameterName, NpgsqlDbType parameterType, int size, string sourceColumn, ParameterDirection direction, bool isNullable, byte precision, byte scale, DataRowVersion sourceVersion, object value) : this() { ParameterName = parameterName; Size = size; SourceColumn = sourceColumn; Direction = direction; IsNullable = isNullable; Precision = precision; Scale = scale; SourceVersion = sourceVersion; Value = value; NpgsqlDbType = parameterType; }
public LogEventSerializedColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Jsonb, int?columnLength = null) : base(dbType, columnLength) { }
/// <summary> /// Initializes a new instance of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> /// class with the parameter m_Name, the <see cref="System.Data.DbType">DbType</see>, the size, /// the source column m_Name, a <see cref="System.Data.ParameterDirection">ParameterDirection</see>, /// the precision of the parameter, the scale of the parameter, a /// <see cref="System.Data.DataRowVersion">DataRowVersion</see> to use, and the /// value of the parameter. /// </summary> /// <param m_Name="parameterName">The m_Name of the parameter to map.</param> /// <param m_Name="parameterType">One of the <see cref="System.Data.DbType">DbType</see> values.</param> /// <param m_Name="size">The length of the parameter.</param> /// <param m_Name="sourceColumn">The m_Name of the source column.</param> /// <param m_Name="direction">One of the <see cref="System.Data.ParameterDirection">ParameterDirection</see> values.</param> /// <param m_Name="isNullable"><b>true</b> if the value of the field can be null, otherwise <b>false</b>.</param> /// <param m_Name="precision">The total number of digits to the left and right of the decimal point to which /// <see cref="Npgsql.NpgsqlParameter.Value">Value</see> is resolved.</param> /// <param m_Name="scale">The total number of decimal places to which /// <see cref="Npgsql.NpgsqlParameter.Value">Value</see> is resolved.</param> /// <param m_Name="sourceVersion">One of the <see cref="System.Data.DataRowVersion">DataRowVersion</see> values.</param> /// <param m_Name="value">An <see cref="System.Object">Object</see> that is the value /// of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see>.</param> public NpgsqlParameter(String parameterName, NpgsqlDbType parameterType, Int32 size, String sourceColumn, ParameterDirection direction, bool isNullable, byte precision, byte scale, DataRowVersion sourceVersion, object value) { this.ParameterName = parameterName; this.Size = size; this.SourceColumn = sourceColumn; this.Direction = direction; this.IsNullable = isNullable; this.Precision = precision; this.Scale = scale; this.SourceVersion = sourceVersion; this.Value = value; if (this.value == null) { this.value = DBNull.Value; type_info = NpgsqlTypesHelper.GetNativeTypeInfo(typeof(String)); } else { NpgsqlDbType = parameterType; //allow the setter to catch exceptions if necessary. } }
protected ColumnWriterBase(NpgsqlDbType dbType, int?columnLength = null) { DbType = dbType; ColumnLength = columnLength; }
/// <summary> /// Initializes a new instance of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> /// class with the parameter m_Name and the data type. /// </summary> /// <param m_Name="parameterName">The m_Name of the parameter to map.</param> /// <param m_Name="parameterType">One of the <see cref="System.Data.DbType">DbType</see> values.</param> public NpgsqlParameter(String parameterName, NpgsqlDbType parameterType) : this(parameterName, parameterType, 0, String.Empty) { }
public TimestampColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Timestamp) : base(dbType) { }
public void duplicated_field_enum_storage_should_be_taken_from_store_options_duplicated_field_enum_storage_when_it_was_changed(EnumStorage enumStorage, NpgsqlDbType expectedNpgsqlDbType) { var storeOptions = new StoreOptions(); storeOptions.Advanced.DuplicatedFieldEnumStorage = enumStorage; var mapping = new DocumentMapping <Target>(storeOptions); var duplicatedField = mapping.DuplicateField(nameof(Target.Color)); duplicatedField.DbType.ShouldBe(expectedNpgsqlDbType); }
public RenderedMessageColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Text, int?columnLength = null) : base(dbType, columnLength) { }
/// <summary> /// Add a new NpgsqlBackendTypeInfo with the given attributes and conversion handlers to this mapping. /// </summary> /// <param name="OID">Type OID provided by the backend server.</param> /// <param name="Name">Type name provided by the backend server.</param> /// <param name="NpgsqlDbType">NpgsqlDbType</param> /// <param name="DbType">DbType</param> /// <param name="Type">System type to convert fields of this type to.</param> /// <param name="BackendTextConvert">Data conversion handler for text encoding.</param> /// <param name="BackendBinaryConvert">Data conversion handler for binary data.</param> public void AddType(Int32 OID, String Name, NpgsqlDbType NpgsqlDbType, DbType DbType, Type Type, ConvertBackendTextToNativeHandler BackendTextConvert = null, ConvertBackendBinaryToNativeHandler BackendBinaryConvert = null) { AddType(new NpgsqlBackendTypeInfo(OID, Name, NpgsqlDbType, DbType, Type, BackendTextConvert = null, BackendBinaryConvert = null)); }
public MessageTemplateColumnWriter(NpgsqlDbType dbType = NpgsqlDbType.Text, int?columnLength = null) : base(dbType, columnLength) { }
internal DbType ToDbType(NpgsqlDbType npgsqlDbType) => _npgsqlDbTypeToDbType.TryGetValue(npgsqlDbType, out var dbType) ? dbType : DbType.Object;
public LevelColumnWriter(bool renderAsText = false, NpgsqlDbType dbType = NpgsqlDbType.Integer, int?columnLength = null) : base(dbType, columnLength) { _renderAsText = renderAsText; }
void Set(string name, NpgsqlDbType type, object value) { if(!Command.Parameters.Contains(name)) Command.Parameters.Add(new NpgsqlParameter(name, type)); Command.Parameters[name].Value = value; }
internal NpgsqlTypeHandler GetByNpgsqlDbType(NpgsqlDbType npgsqlDbType) => _byNpgsqlDbType.TryGetValue(npgsqlDbType, out var handler) ? handler : throw new NpgsqlException($"The NpgsqlDbType '{npgsqlDbType}' isn't present in your database. " + "You may need to install an extension or upgrade to a newer version.");
private static string toUpdateBatchMethod(DocumentMapping mapping, NpgsqlDbType idNpgsqlDbType, string typeName) { var extras = mapping.DuplicatedFields.Select(x => x.ToUpdateBatchParam()).Join(""); return $@" BLOCK:public void RegisterUpdate(UpdateBatch batch, object entity) var document = ({typeName })entity; batch.Sproc(`{mapping.UpsertName}`).Param(document.{mapping.IdMember.Name }, NpgsqlDbType.{idNpgsqlDbType}).JsonEntity(document){extras }; END BLOCK:public void RegisterUpdate(UpdateBatch batch, object entity, string json) var document = ({ typeName})entity; batch.Sproc(`{mapping.UpsertName}`).Param(document.{mapping.IdMember.Name }, NpgsqlDbType.{idNpgsqlDbType}).JsonBody(json){extras}; END "; }
public CommandParameter(object value, NpgsqlDbType npgsqlDbType) { Value = value; DbType = npgsqlDbType; }
/// <summary> /// Initializes a new instance of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> /// class with the parameter m_Name, the <see cref="System.Data.DbType">DbType</see>, the size, /// and the source column m_Name. /// </summary> /// <param m_Name="parameterName">The m_Name of the parameter to map.</param> /// <param m_Name="parameterType">One of the <see cref="System.Data.DbType">DbType</see> values.</param> /// <param m_Name="size">The length of the parameter.</param> /// <param m_Name="sourceColumn">The m_Name of the source column.</param> public NpgsqlParameter(String parameterName, NpgsqlDbType parameterType, Int32 size, String sourceColumn) { this.ParameterName = parameterName; NpgsqlDbType = parameterType; //Allow the setter to catch any exceptions. this.size = size; source_column = sourceColumn; }
/// <summary> /// Adds a <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> to the <see cref="Npgsql.NpgsqlParameterCollection">NpgsqlParameterCollection</see> given the parameter name and the data type. /// </summary> /// <param name="parameterName">The name of the parameter.</param> /// <param name="parameterType">One of the DbType values.</param> /// <returns>The index of the new <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> object.</returns> public NpgsqlParameter Add(string parameterName, NpgsqlDbType parameterType) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Add", parameterName, parameterType); return this.Add(new NpgsqlParameter(parameterName, parameterType)); }
public void InsertNullValue(DbType? dbType, NpgsqlDbType? npgsqlDbType, string fieldName) { if (dbType.HasValue && npgsqlDbType.HasValue || (!dbType.HasValue && !npgsqlDbType.HasValue)) Assert.Fail("Exactly one of dbType and npgsqlDbType must be specified"); using (var command = new NpgsqlCommand(String.Format("INSERT INTO data ({0}) values (:a)", fieldName), Conn)) { if (dbType.HasValue) command.Parameters.Add(new NpgsqlParameter("a", dbType.Value)); else command.Parameters.Add(new NpgsqlParameter("a", npgsqlDbType.Value)); command.Parameters[0].Value = DBNull.Value; var rowsAdded = command.ExecuteNonQuery(); Assert.AreEqual(1, rowsAdded); } var result = ExecuteScalar(String.Format("SELECT COUNT(*) FROM data WHERE {0} IS NULL", fieldName)); // The missed cast is needed as Server7.2 returns Int32 and Server7.3+ returns Int64 Assert.AreEqual(1, result); }
/// <summary> /// Writes a single column in the current row as type <paramref name="npgsqlDbType"/>. /// </summary> /// <param name="value">The value to be written</param> /// <param name="npgsqlDbType"> /// In some cases <typeparamref name="T"/> isn't enough to infer the data type to be written to /// the database. This parameter and be used to unambiguously specify the type. An example is /// the JSONB type, for which <typeparamref name="T"/> will be a simple string but for which /// <paramref name="npgsqlDbType"/> must be specified as <see cref="NpgsqlDbType.Jsonb"/>. /// </param> /// <typeparam name="T">The .NET type of the column to be written.</typeparam> public void Write <T>(T value, NpgsqlDbType npgsqlDbType) => DoWrite(value, npgsqlDbType);
/// <summary> /// Initializes a new instance of the <see cref="NpgsqlParameter">NpgsqlParameter</see> /// </summary> /// <param name="parameterName">The name of the parameter to map.</param> /// <param name="parameterType">One of the <see cref="NpgsqlTypes.NpgsqlDbType">NpgsqlDbType</see> values.</param> /// <param name="size">The length of the parameter.</param> /// <param name="sourceColumn">The name of the source column.</param> public NpgsqlParameter(string parameterName, NpgsqlDbType parameterType, int size, string sourceColumn) : this() { ParameterName = parameterName; NpgsqlDbType = parameterType; _size = size; SourceColumn = sourceColumn; }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType inferredDbType) : this(pgName, npgsqlDbType, new DbType[0], new Type[0], inferredDbType) { }
/// <summary> /// Adds a <see cref="NpgsqlParameter">NpgsqlParameter</see> to the <see cref="NpgsqlParameterCollection">NpgsqlParameterCollection</see> with the parameter name, the data type, the column length, and the source column name. /// </summary> /// <param name="parameterName">The name of the parameter.</param> /// <param name="parameterType">One of the DbType values.</param> /// <param name="size">The length of the column.</param> /// <param name="sourceColumn">The name of the source column.</param> /// <returns>The index of the new <see cref="NpgsqlParameter">NpgsqlParameter</see> object.</returns> public NpgsqlParameter Add(string parameterName, NpgsqlDbType parameterType, int size, string sourceColumn) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Add", parameterName, parameterType, size, sourceColumn); return(this.Add(new NpgsqlParameter(parameterName, parameterType, size, sourceColumn))); }
/// <summary> /// Initializes a new instance of the <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> /// class with the parameter m_Name, the <see cref="System.Data.DbType">DbType</see>, the size, /// and the source column m_Name. /// </summary> /// <param m_Name="parameterName">The m_Name of the parameter to map.</param> /// <param m_Name="parameterType">One of the <see cref="System.Data.DbType">DbType</see> values.</param> /// <param m_Name="size">The length of the parameter.</param> /// <param m_Name="sourceColumn">The m_Name of the source column.</param> public NpgsqlParameter(String parameterName, NpgsqlDbType parameterType, Int32 size, String sourceColumn) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME, parameterName, parameterType, size, source_column); this.ParameterName = parameterName; NpgsqlDbType = parameterType; //Allow the setter to catch any exceptions. this.size = size; source_column = sourceColumn; }
/// <summary> /// Adds a <see cref="NpgsqlParameter">NpgsqlParameter</see> to the <see cref="NpgsqlParameterCollection">NpgsqlParameterCollection</see> given the parameter name and the data type. /// </summary> /// <param name="parameterName">The name of the parameter.</param> /// <param name="parameterType">One of the DbType values.</param> /// <returns>The index of the new <see cref="NpgsqlParameter">NpgsqlParameter</see> object.</returns> public NpgsqlParameter Add(string parameterName, NpgsqlDbType parameterType) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Add", parameterName, parameterType); return(this.Add(new NpgsqlParameter(parameterName, parameterType))); }
internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType[] dbTypes, [CanBeNull] Type[] clrTypes, DbType inferredDbType) : this(pgName, (NpgsqlDbType?)npgsqlDbType, dbTypes, clrTypes, inferredDbType) { }
/// <summary> /// Reads the current column, returns its value according to <paramref name="type"/> and /// moves ahead to the next column. /// If the column is null an exception is thrown. /// </summary> /// <param name="type"> /// In some cases <typeparamref name="T"/> isn't enough to infer the data type coming in from the /// database. This parameter can be used to unambiguously specify the type. An example is the JSONB /// type, for which <typeparamref name="T"/> will be a simple string but for which /// <paramref name="type"/> must be specified as <see cref="NpgsqlDbType.Jsonb"/>. /// </param> /// <typeparam name="T">The .NET type of the column to be read.</typeparam> /// <returns>The value of the column</returns> public T Read <T>(NpgsqlDbType type) => Read <T>(type, false).GetAwaiter().GetResult();
/// <summary> /// Adds a <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> to the <see cref="Npgsql.NpgsqlParameterCollection">NpgsqlParameterCollection</see> with the parameter name, the data type, the column length, and the source column name. /// </summary> /// <param name="parameterName">The name of the parameter.</param> /// <param name="parameterType">One of the DbType values.</param> /// <param name="size">The length of the column.</param> /// <param name="sourceColumn">The name of the source column.</param> /// <returns>The index of the new <see cref="Npgsql.NpgsqlParameter">NpgsqlParameter</see> object.</returns> public NpgsqlParameter Add(string parameterName, NpgsqlDbType parameterType, int size, string sourceColumn) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Add", parameterName, parameterType, size, sourceColumn); return this.Add(new NpgsqlParameter(parameterName, parameterType, size, sourceColumn)); }
//internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType, DbType[] dbTypes=null, Type type=null) // : this(pgName, npgsqlDbType, dbTypes, type == null ? null : new[] { type }) {} internal TypeMappingAttribute(string pgName, NpgsqlDbType npgsqlDbType) : this(pgName, npgsqlDbType, new DbType[0], new Type[0], null) { }