Technisch artikel

ISO 29500 Strict XLSX-bestanden schrijven vanuit Delphi

Een archiefintake weigert een spreadsheet met één enkele klacht: het rootelement van xl/workbook.xml staat in de namespace http://schemas.openxmlformats.org/spreadsheetml/2006/main. Excel opent exact hetzelfde bestand zonder mopperen. Beide uitkomsten zijn correct. ISO/IEC 29500 definieert Strict SpreadsheetML in deel 1 en houdt de transitionele vorm, met zijn legacy-compatibiliteitsfeatures, bij in deel 4, en de URI die de validator citeerde hoort bij Transitional. Een aanbesteding of bewaarbeleid dat ISO 29500 Strict noemt, verwacht in elk onderdeel van het pakket de purl.oclc.org-vocabulaire, en een bestand kan Excel tevreden stellen en die toets volledig niet doorstaan

Wat verandert er tussen Strict en Transitional?

Het zichtbare verschil is het vocabulaire. Een Strict-werkmaponderdeel declareert http://purl.oclc.org/ooxml/spreadsheetml/main als root-namespace en http://purl.oclc.org/ooxml/officeDocument/relationships voor r:id-verwijzingen. De DrawingML-, chart-, picture- en spreadsheet-drawing-namespaces verschuiven op dezelfde manier, en de documentproperty-onderdelen doen dat ook. Relationshiptypes veranderen mee: het root-relationshipsonderdeel wijst naar http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument, en de extended- en custom-propertytypes worden camelCased als extendedProperties en customProperties, waar Transitional ze met koppeltekens schrijft

Het minder zichtbare verschil is het bereik. Strict laat de delen van het transitionele schema weg die alleen bestonden om legacy binair gedrag te dragen, en het heeft voor de extensies die Office later toevoegde helemaal geen vocabulaire. Zoeken-en-vervangen over strings dicht die kloof niet, omdat sommige features simpelweg geen Strict-spelling hebben. Een pakket converteren betekent daarmee twee klussen: alles hernoemen dat een Strict-equivalent heeft, en beslissen wat je met alles wat dat niet heeft doet

HotXLS StrictOOXML-vocabulairewissel in het XLSX-pakket: werkboek-, relationship- en extended-properties-parts herschreven van openxmlformats transitional-namespaces naar purl.oclc.org strict-namespaces
Elk onderdeel wisselt tegelijk van woordenschat, van de root namespace via relationship-types naar het camelCase extendedProperties-type; geen enkele transitional namespace mag ergens in het pakket overleven

Een Delphi-export omschakelen naar StrictOOXML

In HotXLS is de schakelaar één Boolean op TXLSXWorkbook, StrictOOXML, die standaard op False staat. Code die een werkmap opbouwt verandert niet. Je bouwt sheets, cellen en formules zoals altijd, stelt de property in en slaat op. SaveAs geeft 1 terug bij succes; al het andere betekent dat het pakket niet is weggeschreven, en de reden staat in Diagnostics

var
  Wb: TXLSXWorkbook;
  Sh: TXLSXWorksheet;
  I: Integer;
begin
  Wb := TXLSXWorkbook.Create;
  try
    Sh := Wb.Sheets.Add('Data');
    Sh.Cells[1, 1].Value := 'Product';
    Sh.Cells[1, 2].Value := 'Amount';
    Sh.Cells[2, 1].Value := 'Widget';
    Sh.Cells[2, 2].Value := 17;
    Sh.Cells[3, 1].Value := 'Gadget';
    Sh.Cells[3, 2].Value := 25;
    Sh.Cells[4, 2].Formula := '=SUM(B2:B3)';

    Wb.StrictOOXML := True;            // ISO/IEC 29500 Strict-vocabulaire
    if Wb.SaveAs('archive-copy.xlsx') <> 1 then
    begin
      for I := 0 to Wb.Diagnostics.Count - 1 do
        WriteLn(Wb.Diagnostics[I].Message);
      raise Exception.Create('Strict save was refused');
    end;
  finally
    Wb.Free;
  end;
end;

De property wordt aan het begin van elke opslagbewerking gelezen en stuurt een per-opslag-schakelaar aan waar de writers naar kijken, dus een opslag die halverwege mislukt kan de strikte vertaling niet aangezet laten voor de volgende. Op een server waar één werkmapobject meerdere exportverzoeken beantwoordt, kun je StrictOOXML tussen aanroepen door omzetten en krijgt elke opslag precies de vocabulaire die er is gevraagd

Twee grenzen zijn handig om vooraf te kennen. Strikte uitvoer geldt voor de Open XML-formaten: workbook, template en macro-enabled template. .xlsb vragen terwijl StrictOOXML op True staat wordt geweigerd met een diagnostic die je vraagt de property uit te zetten, want het binaire formaat heeft geen Strict-variant. En het openen van een bestand dat Excel als "Strict Open XML Spreadsheet" heeft opgeslagen zet de property niet voor je aan. Laad zo'n bestand en sla het op zonder StrictOOXML aan te raken, dan krijg je een transitioneel pakket terug

Waarom weigert een strikte opslag te draaien?

Een strikte opslag weigert te draaien zodra de werkmap content bevat die ISO 29500 Strict niet kan uitdrukken. De families die HotXLS controleert zijn VBA-projecten, formuliercontrols met hun ctrlProps-onderdelen, threaded comments (het moderne persons-and-threads-model, niet klassieke notities), slicers, metadata voor dynamische matrices, databalken die voor features als effen vulling, negatieve balkkleuren of een eigen as op het extensieblok van 2009 leunen, en Timelines zolang er geen conversiebeleid is gekozen

HotXLS strikte opslagpoort in Delphi: SaveAs met StrictOOXML weigert VBA-projecten, formuliercontrols, threaded comments, slicers en metadata van dynamische matrices en rundt alleen af wanneer geen enkele verboden feature aanwezig is
Een strikte opslag toetst de werkmap aan wat ISO 29500 Strict kan uitdrukken en benoemt elke blokkerende feature in plaats van een pakket weg te schrijven dat alleen maar conformiteit claimt

Weigeren is hier de juiste default. Het alternatief is het macroproject of de slicers laten vallen en het resultaat toch als Strict stempelen; daarmee geef je iemand een werkmap die netjes opent en zich anders gedraagt dan degene die werd geëxporteerd. Excel vlagt dat nooit. Een weigering benoemt de feature terwijl je code nog weet bij welk rapport het hoorde. De meeste weigeringen komen als SaveAs die -1 teruggeeft met een diagnostic als StrictOOXML: Strict output cannot embed VBA. De opslag van dynamische-matrixmetadata wordt beslist terwijl het pakket wordt weggeschreven, dus een formule die in deze sessie is toegekend kan de opslag nog stoppen met een uitzondering die de metadata noemt; wikkel een strikte SaveAs dus ook in try..except, naast het controleren van het resultaat. Heeft de werkmap zijn macro's nodig, dan hoort die thuis op het transitionele .xlsm-pad uit VBA-projecten en externe koppelingen behouden

Dat hoeft niet via een opslag te ontdekken. GetConversionReport inspecteert de werkmap zonder te herberekenen en geeft een TXLSConversionReport terug waarvan de items een featurenaam, een getrouwheidsniveau, een werkbladindex en een melding dragen. Onder StrictOOXML komen de blokkerende items terug als xlsConversionUnsupported. Het Timeline-geval laat ook de ene plek zien waar je bewust content inruilt tegen conformiteit: StrictTimelineOutputPolicy op xlsxStrictTimelineDateCriteria zetten zet ondersteunde Timeline-selecties om naar standaard draaitabel-datumcriteria en laat de Timeline-UI weg, samen met zijn cache-onderdelen, relationships en gedefinieerde namen. Het rapport vermeldt dat als xlsConversionDropped, en de bronwerkmap in het geheugen blijft ongewijzigd

function StrictBlockers(Wb: TXLSXWorkbook; Log: TStrings): Boolean;
var
  Report: TXLSConversionReport;
  I: Integer;
begin
  Wb.StrictOOXML := True;
  // De gedocumenteerde Timeline-ruil accepteren: datumcriteria blijven, Timeline-UI gaat weg
  Wb.StrictTimelineOutputPolicy := xlsxStrictTimelineDateCriteria;
  Report := Wb.GetConversionReport(xlsConversionOpenXmlWorkbook);
  try
    Result := False;
    for I := 0 to Report.Count - 1 do
      if Report[I].Fidelity in [xlsConversionUnsupported, xlsConversionDropped] then
      begin
        Log.Add(Format('%s (sheet %d): %s',
          [Report[I].Feature, Report[I].SheetIndex, Report[I].Message]));
        if Report[I].Fidelity = xlsConversionUnsupported then
          Result := True;
      end;
  finally
    Report.Free;
  end;
end;

Draai dit vóór de export en log elke regel die het teruggeeft. Een werkbladindex van -1 markeert een item op werkmapniveau zoals het VBA-project; werkbladitems dragen het werkbladnummer vanaf 1 en de werkbladnaam, passend bij de manier waarop Sheets is geïndexeerd. Het rapport ziet dynamische-matrixmetadata die een geladen werkmap al bevat; voor formules die in code zijn toegekend vertrouw je op de scalaire herschrijving in de volgende sectie

De formule die stilletjes een dynamische matrix wordt

De weigering die mensen verrast, is dynamische-matrixmetadata in een werkmap die nooit FILTER of SEQUENCE gebruikte. Excel 365 evalueert een operator toegepast op een bereik over meerdere cellen als een matrix, ook binnen een reductiefunctie, dus =SUM(B2:B4*C2:C4) is in Excel's ogen een matrixformule. Wijs je die tekst toe aan Formula, dan slaat HotXLS de cel op zoals Excel dat zou doen: als dynamische matrix van één cel met een cm-verwijzing naar xl/metadata.xml; anders zou Excel bij het laden impliciete doorsnijding toepassen en #VALUE! tonen. De achtergrond staat in matrixoperatorformules en impliciete doorsnijding. Strict heeft geen vocabulaire voor dat metadata-onderdeel, dus de opslag stopt

// Matrixopslag: het product van twee bereiken wordt als matrix geëvalueerd
Sh.Cells[5, 2].Formula := '=SUM(B2:B4*C2:C4)';    // blokkeert een strikte opslag

// Scalaire opslag: gewone bereikargumenten, zelfde totaal
Sh.Cells[5, 2].Formula := '=SUMPRODUCT(B2:B4,C2:C4)';

Voor Strict-exports schrijf je de scalaire vorm. SUMPRODUCT met gewone bereikargumenten geeft hetzelfde totaal, vereist geen dynamische-matrixondersteuning in wat het bestand later ook leest, en houdt de cel helemaal buiten het metadata-onderdeel. Dezelfde herschrijving werkt voor voorwaardelijke tellingen: SUMPRODUCT((A2:A4="x")*1) vermenigvuldigt nog steeds matrices, dus kies daar liever COUNTIF(A2:A4,"x"). Wil een rapport echt spill-resultaten tonen, dan heeft het transitionele uitvoer nodig

Behouden onderdelen worden herbouwd in plaats van gekopieerd

De werkblad-XML is het makkelijke deel van strikte uitvoer. Het moeilijke deel is alles wat een snelle writer liever letterlijk kopieert. Als HotXLS een bestaand pakket opent, houdt het het originele thema, connections, externe koppelingen, grafieken en draaitabelonderdelen vast, en bij een transitionele opslag kopieert het hun gecomprimeerde bytes rechtstreeks door zolang het model niet is veranderd. Dat is de juiste zet voor getrouwheid en de verkeerde voor Strict, want die bytes dragen nog steeds transitionele namespaces

Met StrictOOXML aan wordt het byte-kopieerpad voor al die onderdelen omzeild. Connections, externe koppelingen en grafieken worden vanuit het model herbouwd; het thema en de vastgelegde draaitabel-, cachedefinitie- en cacherecords-XML worden opnieuw afgespeeld via de namespacevertaler. Die vertaler parseert elke starttag en herschrijft maar twee dingen: namespace-declaraties, en het Type-attribuut van Relationship-elementen in .rels-onderdelen. Celtekst, andere attribuutwaarden, comments en CDATA-secties gaan byte voor byte door, dus een gedeelde tekenreeks die toevallig http://schemas.openxmlformats.org/... bevat wordt nooit aangeraakt. Namespace-URI's buiten schemas.openxmlformats.org, zoals de Microsoft-extensie-namespaces binnen extLst-blokken, blijven zoals ze zijn; wijst je validator ook extensiecontent af naast transitionele namespaces, haal die features dan uit de bronwerkmap vóór de export

HotXLS pad voor strikte uitvoer van behouden XLSX-onderdelen: thema, connections, externe koppelingen, grafieken en pivotcaches wisselen van letterlijke byte-kopie naar herbouw of een vertalende replay die alleen namespace-declaraties en relationshiptypes herschrijft
Gekopieerde gecomprimeerde bytes zouden transitionele namespaces het strikte pakket binnensmokkelen, dus de behouden paden omzeilen het snelle pad; vertaling herschrijft alleen namespace-declaraties en relationshiptypes, en het gestreamde werkbladskelet wordt vertaald voordat het bij sheetData wordt gesplitst

Gestreamde werkbladen volgen dezelfde regel met één draai. De writer bouwt eerst het werkbladskelet, vertaalt het, en splitst het pas daarna op <sheetData> om de rijen daartussen te streamen. Rijblokken bevatten geen vocabulaire-URI's, dus grote sheets betalen niets extra voor strikte uitvoer. Gedeelde tekenreeksen en draaitabelcacherecords werken hetzelfde: alleen het headerelement wordt vertaald. Meer over de behoudkant staat in verliesvrije round-trips van thema's, extensielijsten en calcChain

Strict-bestanden lezen en controleren wat je schreef

Bestanden die Excel als Strict opsloeg openen als elke andere werkmap. HotXLS mapt Strict-relationshiptypes op hun transitionele tegenhangers waar ook een relationshipsonderdeel wordt geparseerd: bij de pakketwortel, werkbladen, drawings, externe koppelingen en draaitabellen, en de lezer herkent elementnamen via de namespace-URI in plaats van via het prefix. Generators van derden binden prefixes vrij, dus dezelfde mechaniek dient ook gewone bestanden; ze staat beschreven in OPC-relationshipresolutie in XLSX-pakketten. Bij een transitionele opslag van zo'n bestand wordt elk behouden XML-onderdeel waarvan de root nog een Strict-namespace gebruikt op de uitweg weer teruggezet, zodat het resultaat niet half het ene en half het andere vocabulaire wordt

Verifieer strikte uitvoer tegen het pakket, nooit tegen Excel, dat beide vormen problemloos opent. Unzip het resultaat en controleer drie dingen: xl/workbook.xml declareert http://purl.oclc.org/ooxml/spreadsheetml/main, geen enkel onderdeel bevat de string schemas.openxmlformats.org/spreadsheetml, en de Type-waarden in _rels/.rels en xl/_rels/workbook.xml.rels beginnen met http://purl.oclc.org/ooxml/. Een korte findstr /s /m "schemas.openxmlformats.org/spreadsheetml" *.xml over de uitgepakte map hoort niets op te leveren

Open het bestand daarna opnieuw via TXLSXWorkbook.Open en vergelijk waarden, formules, getalnotaties en hyperlinks met de bronwerkmap. Die teruglezing test tegelijk de lezerskant van de mapping. Bevat de werkmap grafieken of draaitabellen, neem ze dan op in de vergelijking, want beide wisselen onder StrictOOXML van byte-kopie naar een herbouwd of opnieuw afgespeeld pad

Strikte uitvoer, Strict-bewust lezen en verliesvrije round-trips van transitionele pakketten delen één OOXML-engine in HotXLS for Delphi and C++Builder; de HotXLS Delphi spreadsheet component-pagina zet de formaten en features op een rij die de engine dekt