如何使用非默认列顺序构造 Sql Server TVP？

Question

My scenario is simple - I create a TVP with an IEnumerable<SqlDataRecord> as its value and execute the query using it.

The results I get back do not make any sense. So, I wrote a TraceSql function that dumps the SQL along with its parameters in a way ready to be copied and pasted into the SSMS.

I was puzzled to discover, that the SQL displayed by my function produces the correct results, when pasted to SSMS and ran there.

Finally, I started Sql Server profiler and found out the source of the mystery.

Here is the SQL produced by my TraceSql function:

DECLARE @AdmSiteId Int = 93
DECLARE @src dbo.TableOfObjectChecksum2
INSERT INTO @src (Id,Checksum,AuxId) VALUES
 (8395,258295360,1)
,(8395,1114574098,2)
,(8395,-19039848,3)
,(8395,337145572,4)
,(8395,1083939112,5)


SELECT ISNULL(src.Id, dst.ClientId) Id, ISNULL(src.AuxId, dst.ClientLegalId) AuxId,
  CASE
    WHEN src.Checksum IS NULL THEN 0
    WHEN dst.Checksum IS NOT NULL THEN 1
    ELSE 2
  END Checksum
FROM @src src
FULL JOIN AdmCustomerInfoLegal dst ON src.Id = dst.ClientId AND src.AuxId = dst.ClientLegalId
LEFT JOIN AdmClientSite cs ON cs.AdmClientMasterId = dst.ClientId
WHERE (cs.AdmSiteId = @AdmSiteId OR cs.AdmSiteId IS NULL) AND (src.Checksum IS NULL OR dst.Checksum IS NULL OR src.Checksum <> dst.Checksum)
ORDER BY Checksum, Id, AuxId

Now here is the SQL as captured by the profiler:

declare @p4 dbo.TableOfObjectChecksum2
insert into @p4 values(8395,258295360,1)
insert into @p4 values(8395,1114574098,2)
insert into @p4 values(8395,-19039848,3)
insert into @p4 values(8395,337145572,4)
insert into @p4 values(8395,1083939112,5)

exec sp_executesql N'
SELECT ISNULL(src.Id, dst.ClientId) Id, ISNULL(src.AuxId, dst.ClientLegalId) AuxId, 
  CASE 
    WHEN src.Checksum IS NULL THEN 0
    WHEN dst.Checksum IS NOT NULL THEN 1
    ELSE 2 
  END Checksum
FROM @src src
FULL JOIN AdmCustomerInfoLegal dst ON src.Id = dst.ClientId AND src.AuxId = dst.ClientLegalId
LEFT JOIN AdmClientSite cs ON cs.AdmClientMasterId = dst.ClientId
WHERE (cs.AdmSiteId = @AdmSiteId OR cs.AdmSiteId IS NULL) AND (src.Checksum IS NULL OR dst.Checksum IS NULL OR src.Checksum <> dst.Checksum)
ORDER BY Checksum, Id, AuxId',N'@AdmSiteId int,@src [dbo].[TableOfObjectChecksum2] READONLY',@AdmSiteId=93,@src=@p4

Notice the INSERT statements in the SQL captured by the profiler do not specify the column list. However, when I create the TVP I specify a different order of the columns.

Here is the schema of the dbo.TableOfObjectChecksum2 table UDT:

CREATE TYPE [dbo].[TableOfObjectChecksum2] AS TABLE(
    [Id] [int] NOT NULL,
    [AuxId] [int] NOT NULL,
    [Checksum] [int] NOT NULL,
    PRIMARY KEY ([Id],[AuxId])
)

Here is how I create the respective TVP in C#:

var items = GetItemsSomehow();
var metadata = new[]
{
  new SqlMetaData("Id", SqlDbType.Int),
  new SqlMetaData("Checksum", SqlDbType.Int),
  new SqlMetaData("AuxId", SqlDbType.Int)
};
new SqlParameter("src", SqlDbType.Structured)
{
  TypeName = "dbo.TableOfObjectChecksum2",
  SqlValue = items.Select(x =>
  {
    var rec = new SqlDataRecord(metadata);
    rec.SetInt32(0, x.ClientId);
    rec.SetInt32(1, x.Checksum);
    rec.SetInt32(2, x.ClientLegalId);
    return rec;
  }),
};

I thought that the column order I specified in the metadata array defines the matching between the ordinals and the fields. But it is not.

Now I understand that the best is to change my TVP to pass the columns in the same order as defined in the database. However, out of curiousity, how am I to create a TVP with a different column order, like in my example (which does not work)?

EDIT

My English is obviously inadequate to explain myself.

Please, examine the SqlMetadata[] argument passed to SqlDataRecord constructor. Does the order of the items matter? I thought it does. So, if I pass

new[]
{
  new SqlMetaData("Id", SqlDbType.Int),
  new SqlMetaData("Checksum", SqlDbType.Int),
  new SqlMetaData("AuxId", SqlDbType.Int)
};

then it means something like this "In the batch insert SQL statement specify the columns in the order Id,Checksum,AuxId". In other words, I thought that the batch insert statement generated by ADO.NET given the aforementioned metadata is something like this:

INSERT INTO WhatEver (Id,Checksum,AuxId) VALUES (...),(...),...,(...)

I think it is legitimate to have assumed such a logic. Given this assumption the code

rec.SetInt32(0, x.ClientId);
rec.SetInt32(1, x.Checksum);
rec.SetInt32(2, x.ClientLegalId);

is absolutely valid, because:

• ordinal 0 is Id metadata - given ClientId
• ordinal 1 is Checksum metadata - given Checksum
• ordinal 2 is AuxId metadata - given ClientLegalId

However, what I have stumbled upon is that the order of the metadata items does not matter to ADO.NET internals, because the insert statement actually produced by it is something like this:

INSERT INTO WhatEver VALUES (...)
INSERT INTO WhatEver VALUES (...)
...
INSERT INTO WhatEver VALUES (...)

Meaning, no matter how I order the metadata items, the actual insert SQL goes by the order of the columns in the database schema. And of course, the code

rec.SetInt32(0, x.ClientId);
rec.SetInt32(1, x.Checksum);
rec.SetInt32(2, x.ClientLegalId);

becomes invalid, because in the database:

• ordinal 1 corresponds to AuxId and now it is given the Checksum
• ordinal 2 corresponds to Checksum and now it is given the ClientLegalId

So, my assumption is wrong.

Now my question - is it still possible to batch insert using a collection of SqlDataRecord objects and have a custom order of the columns? Or pass only the required columns, relying on the defaults and NULLs to kick in? Because an insert SQL without giving an explicit column list must provide the values for each and every column, even the nullable and default ones . Otherwise Sql Server spits out Column name or number of supplied values does not match table definition.

Answer 1

I'm experiencing this issue and unfortunately there's no way to ignore the order of columns. The only minor improvement I was able to do was strong-typing:

 var record = new SqlDataRecord(
        new SqlMetaData(nameof(x.Id), SqlDbType.Int),
        new SqlMetaData(nameof(x.Checksum), SqlDbType.Int),
        new SqlMetaData(x.nameof(x.AuxId), SqlDbType.Int));
    
    var index = record.GetOrdinal(nameof(x.Id));
    record.SetInt32(index, x.Id);
    index = record.GetOrdinal(nameof(x.Checksum));
    record.SetInt32(index, x.Checksum);
    index = record.GetOrdinal(nameof(x.AuxId));
    record.SetInt32(index, x.AuxId);

Still the order matters and the name of columns and entities' property name should match.

Answer 2

But the select does not match.
And why inconsistent names?

 rec.SetInt32(0, x.ClientId);
 rec.SetInt32(1, x.Checksum);
 rec.SetInt32(2, x.ClientLegalId);


CREATE TYPE [dbo].[TableOfObjectChecksum2] AS TABLE(
    [Id] [int] NOT NULL,
    [AuxId] [int] NOT NULL,
    [Checksum] [int] NOT NULL,
    PRIMARY KEY ([Id],[AuxId])
)