C# DB2 EF Insert erorr

Question

I currently have some problems inserting a new row into a table. The problem is likely, that the statement has double-quotes surrounding the primary key for whatever reason.

select "OID" as ""OID"" 
from new table (insert into "PAQ"."TPAQ100_AUFTRAG"("EKVNR", "AUFTRAG_ERSTELLT_AM", "NACHNAME", "VORNAME", "GEBURTSDATUM", "SACHBEARBEITER_NACHNAME", "SACHBEARBEITER_VORNAME", "SACHBEARBEITER_USER", "DIENSTSTELLE", "LEI_ARZT_ANGEFORDERT", "LEI_ZAHNARZT_ANGEFORDERT", "LEI_APO_ANGEFORDERT", "LEI_KH_ANGEFORDERT", "LEI_SONSTIGE_LE_ANGEFORDERT", "GUELTIG_VON", "GUELTIG_BIS", "AUSGABEWEG", "AUFTRAG_HERKUNFT")
    values (@p0, @p1, @p2, @p3, @p4, @p5, @p6, @p7, @p8, @p9, @p10, @p11, @p12, @p13, @p14, @p15, @p16, @p17))

Now I already have EnableEFCaseSensitivity on false and honestly have no clue where the quotes come from. I do use the Column attribute, but not for OID. I only set the Key attribute and that's it. The Columns (as well as the name of the table) are all in Caps.

The error is:

ERROR [42601] [IBM][DB2/AIX64] SQL0104N An unexpected token """" was found following "select "OID" as ". Expected tokens may include: "".

The model-class:

    [Table("PAQ.TPAQ100_AUFTRAG")]
    public class Auftrag
    {
        [Key]
        public long OID { get; set; }

        [Required]
        [StringLength(10)]
        [Column("EKVNR")]
        public string Ekvnr { get; set; }

        [Column("AUFTRAG_ERSTELLT_AM")]
        public DateTime CreatedAt { get; set; }

        [Required]
        [StringLength(60)]
        [Column("NACHNAME")]
        public string Nachname { get; set; }

        [Required]
        [StringLength(30)]
        [Column("VORNAME")]
        public string Vorname { get; set; }

        [Column("GEBURTSDATUM", TypeName = "date")]
        public DateTime GebDat { get; set; }

        [StringLength(32)]
        [Column("SACHBEARBEITER_NACHNAME")]
        public string SachbearbeiterNachname { get; set; }

        [StringLength(32)]
        [Column("SACHBEARBEITER_VORNAME")]
        public string SachbearbeiterVorname { get; set; }

        [StringLength(20)]
        [Column("SACHBEARBEITER_USER")]
        public string SachbearbeiterUser { get; set; }

        [StringLength(7)]
        [Column("DIENSTSTELLE")]
        public string SachbearbeiterDst { get; set; }

        [Column("LEI_ARZT_ANGEFORDERT")]
        public short AerztlicheLeistungen { get; set; }

        [Column("LEI_ZAHNARZT_ANGEFORDERT")]
        public short ZahnaerztlicheLeistungen { get; set; }

        [Column("LEI_APO_ANGEFORDERT")]
        public short Arzneimittel { get; set; }

        [Column("LEI_KH_ANGEFORDERT")]
        public short KrankenhausBehandlung { get; set; }


        [Column("LEI_SONSTIGE_LE_ANGEFORDERT")]
        public short SonstigeLeistungen { get; set; }

        [Column("GUELTIG_VON", TypeName = "date")]
        public DateTime GueltigAb { get; set; }

        [Column("GUELTIG_BIS", TypeName = "date")]
        public DateTime GueltigBis { get; set; }

        [Required]
        [StringLength(1)]
        [Column("AUSGABEWEG", TypeName = "character")]
        public string AusgabeWeg { get; set; }

        [Required]
        [StringLength(1)]
        [Column("AUFTRAG_HERKUNFT", TypeName = "character")]
        public string AuftragHerkunft { get; set; }
    }

The repository-function:

public void Create(Auftrag auftrag)
{
    Logger.LogInfo($"Versuche den Auftrag für Versicherten {auftrag.Nachname}, {auftrag.Vorname} in die Auftragsdatenbank zu schreiben");
    auftrag.CreatedAt = DateTime.Now;

    _context.Auftraege.Add(auftrag);
    //Loggt die Query zwecks Fehleranalyse
    _context.Database.Log = Logger.LogInfo;
    _context.SaveChanges();
}

The context-class:

public partial class AuftragDbContext : DbContext
    {
        public AuftragDbContext(DbConnection db2Connection)
            : base(db2Connection, true)
        {
        }

        public DbSet<Auftrag> Auftraege { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Auftrag>()
                .Property(e => e.Ekvnr)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.Nachname)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.Vorname)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.SachbearbeiterNachname)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.SachbearbeiterVorname)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.SachbearbeiterUser)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.SachbearbeiterDst)
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.AuftragHerkunft)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<Auftrag>()
                .Property(e => e.AusgabeWeg)
                .IsFixedLength()
                .IsUnicode(false);
        }

        /// <summary>
        /// Dient dem Abfangen von Exceptions im Prozess des Sicherns der datenbankseitigen Operationen
        /// </summary>
        /// <returns></returns>
        public override int SaveChanges()
        {
            try
            {
                return base.SaveChanges();
            }
            catch (DbEntityValidationException dbValEx)
            {
                var values = dbValEx.EntityValidationErrors;
                if (values == null) throw new ArgumentNullException(nameof(values));
                throw;
            }
            catch (DbUpdateException dbUpEx)
            {
                throw dbUpEx;
            }
        }
    }
    /// <summary>
    /// Gibt die Datenbankconnection abhängig von der aktuellen Domäne zurück
    /// </summary>
    public static class AuftragContextFactory
    {
        private static string _connectionString = null;

        private static DB2Connection GetConnectionString()
        {
            if (_connectionString != null)
            {
                return new DB2Connection(_connectionString);
            }

            var connstrBulder = new DakampClientConnectionStringBuilder(EnvironmentHandler.Environment);
            var connStr = connstrBulder.GetClientConnectionString(DatabaseType.AuftragsDB);
            var db2ConStrBldr = new DB2ConnectionStringBuilder(connStr)
            {
                //Queries laufen so lange, bis sie durch sind unabhängig vom CommandTimeout
                QueryTimeout = 0,
                EnableEFCaseSensitivity = false,
                ConcurrentAccessResolution = "CurrentlyCommitted",
            };
            _connectionString = db2ConStrBldr.ConnectionString;
            return new DB2Connection(_connectionString);
        }

        public static AuftragDbContext AuftragDb => new AuftragDbContext(GetConnectionString());
    }

I've spent the last few hours searching for a solution without finding anything helpful at all.

Answer 1

Even though it's not a 100% satisfying answer you can use Command Interceptors to modify the sql-query, before it is exexuted:

public void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
{
    command.CommandText = command.CommandText.Replace("\"\"", "\"").Trim();
    Logger.LogInfo("ReaderExecuted: " +
                   $" IsAsync: {interceptionContext.IsAsync}, Command Text: {command.CommandText}");
}

All I did was to replace double-quotes with one quote and it's working properly.