441 lines
16 KiB
PowerShell
441 lines
16 KiB
PowerShell
param(
|
|
[string]$Server = $env:ONEC_SQL_SERVER,
|
|
[string]$Database = $env:ONEC_SQL_DATABASE,
|
|
[string]$User = $env:ONEC_SQL_USER,
|
|
[string]$Password = $env:ONEC_SQL_PASSWORD,
|
|
[string]$ReadResultPath,
|
|
[string]$RouteIndexPath,
|
|
[string]$OutputPath
|
|
)
|
|
|
|
Set-StrictMode -Version Latest
|
|
$ErrorActionPreference = "Stop"
|
|
|
|
if (-not $Server) { throw "Server is required. Use -Server or ONEC_SQL_SERVER." }
|
|
if (-not $Database) { throw "Database is required. Use -Database or ONEC_SQL_DATABASE." }
|
|
if (-not $User) { throw "User is required. Use -User or ONEC_SQL_USER." }
|
|
if (-not $Password) { throw "Password is required. Use -Password or ONEC_SQL_PASSWORD." }
|
|
if (-not $ReadResultPath) { throw "ReadResultPath is required." }
|
|
if (-not $RouteIndexPath) { throw "RouteIndexPath is required." }
|
|
if (-not $OutputPath) { throw "OutputPath is required." }
|
|
|
|
function Test-HasProperty {
|
|
param([object]$Object, [string]$Name)
|
|
return $null -ne $Object -and ($Object.PSObject.Properties.Name -contains $Name)
|
|
}
|
|
|
|
function Convert-HexToBytes {
|
|
param([string]$Hex)
|
|
if (-not $Hex -or ($Hex.Length % 2) -ne 0) { return $null }
|
|
$bytes = [byte[]]::new($Hex.Length / 2)
|
|
for ($i = 0; $i -lt $bytes.Length; $i++) {
|
|
$bytes[$i] = [Convert]::ToByte($Hex.Substring($i * 2, 2), 16)
|
|
}
|
|
return $bytes
|
|
}
|
|
|
|
function Convert-SqlValue {
|
|
param([object]$Value)
|
|
if ($null -eq $Value -or $Value -is [DBNull]) { return $null }
|
|
if ($Value -is [byte[]]) {
|
|
return [pscustomobject]@{
|
|
kind = "binary"
|
|
length = $Value.Length
|
|
hex = ([BitConverter]::ToString($Value) -replace "-", "").ToLowerInvariant()
|
|
}
|
|
}
|
|
if ($Value -is [DateTime]) { return $Value.ToString("o") }
|
|
return $Value
|
|
}
|
|
|
|
function Get-PhysicalTable {
|
|
param([string]$Kind, [int]$SqlNumber)
|
|
switch ($Kind) {
|
|
"Catalog" { return "_Reference$SqlNumber" }
|
|
"Document" { return "_Document$SqlNumber" }
|
|
"Enum" { return "_Enum$SqlNumber" }
|
|
default { return $null }
|
|
}
|
|
}
|
|
|
|
function Get-StorageRole {
|
|
param([string]$Kind)
|
|
switch ($Kind) {
|
|
"Catalog" { return "Reference" }
|
|
"Document" { return "Document" }
|
|
"Enum" { return "Enum" }
|
|
default { return $null }
|
|
}
|
|
}
|
|
|
|
function Get-ReferenceKind {
|
|
param([string]$RefKind)
|
|
switch ($RefKind) {
|
|
"CatalogRef" { return "Catalog" }
|
|
"DocumentRef" { return "Document" }
|
|
"EnumRef" { return "Enum" }
|
|
default { return $null }
|
|
}
|
|
}
|
|
|
|
function Get-Columns {
|
|
param(
|
|
[System.Data.SqlClient.SqlConnection]$Connection,
|
|
[string]$Table
|
|
)
|
|
$command = $Connection.CreateCommand()
|
|
$command.CommandText = @"
|
|
SELECT COLUMN_NAME
|
|
FROM INFORMATION_SCHEMA.COLUMNS
|
|
WHERE TABLE_NAME = @table
|
|
ORDER BY ORDINAL_POSITION
|
|
"@
|
|
$null = $command.Parameters.Add("@table", [System.Data.SqlDbType]::NVarChar, 128)
|
|
$command.Parameters["@table"].Value = $Table
|
|
$reader = $command.ExecuteReader()
|
|
$columns = New-Object System.Collections.Generic.List[string]
|
|
try {
|
|
while ($reader.Read()) {
|
|
$columns.Add([string]$reader.GetValue(0))
|
|
}
|
|
}
|
|
finally {
|
|
$reader.Close()
|
|
$command.Dispose()
|
|
}
|
|
return [string[]]$columns.ToArray()
|
|
}
|
|
|
|
function Quote-Identifier {
|
|
param([string]$Name)
|
|
return "[" + ($Name -replace "]", "]]") + "]"
|
|
}
|
|
|
|
function Select-PresentationColumns {
|
|
param([string]$Kind, [string[]]$Columns)
|
|
$wanted = New-Object System.Collections.Generic.List[string]
|
|
foreach ($column in @("_IDRRef", "_Code", "_Description", "_Number", "_Date_Time", "_Posted", "_Marked", "_EnumOrder")) {
|
|
if ($Columns -contains $column) {
|
|
$wanted.Add($column)
|
|
}
|
|
}
|
|
if ($wanted.Count -eq 0 -and ($Columns -contains "_IDRRef")) {
|
|
$wanted.Add("_IDRRef")
|
|
}
|
|
return [string[]]$wanted.ToArray()
|
|
}
|
|
|
|
function Resolve-ReferenceRow {
|
|
param(
|
|
[System.Data.SqlClient.SqlConnection]$Connection,
|
|
[string]$Table,
|
|
[string[]]$Columns,
|
|
[byte[]]$IdBytes
|
|
)
|
|
if (-not ($Columns -contains "_IDRRef")) {
|
|
return [pscustomobject]@{ found = $false; values = $null; reason = "target_table_without__IDRRef" }
|
|
}
|
|
$select = ($Columns | ForEach-Object { Quote-Identifier $_ }) -join ", "
|
|
$command = $Connection.CreateCommand()
|
|
$command.CommandText = "SELECT TOP (1) $select FROM $(Quote-Identifier $Table) WHERE [_IDRRef] = @id;"
|
|
$null = $command.Parameters.Add("@id", [System.Data.SqlDbType]::Binary, 16)
|
|
$command.Parameters["@id"].Value = $IdBytes
|
|
$reader = $command.ExecuteReader()
|
|
try {
|
|
if (-not $reader.Read()) {
|
|
return [pscustomobject]@{ found = $false; values = $null; reason = "not_found" }
|
|
}
|
|
$values = [ordered]@{}
|
|
for ($i = 0; $i -lt $reader.FieldCount; $i++) {
|
|
$values[$reader.GetName($i)] = Convert-SqlValue $reader.GetValue($i)
|
|
}
|
|
return [pscustomobject]@{ found = $true; values = [pscustomobject]$values; reason = $null }
|
|
}
|
|
finally {
|
|
$reader.Close()
|
|
$command.Dispose()
|
|
}
|
|
}
|
|
|
|
function Find-IdTables {
|
|
param(
|
|
[System.Data.SqlClient.SqlConnection]$Connection,
|
|
[string]$TableLike,
|
|
[byte[]]$IdBytes
|
|
)
|
|
$command = $Connection.CreateCommand()
|
|
$command.CommandTimeout = 0
|
|
$command.CommandText = @"
|
|
DECLARE @id binary(16) = @p;
|
|
DECLARE @sql nvarchar(max) = N'';
|
|
SELECT @sql = @sql + N'IF EXISTS (SELECT 1 FROM ' + QUOTENAME(TABLE_NAME) + N' WHERE [_IDRRef] = @id) SELECT N''' + TABLE_NAME + N''' AS table_name;'
|
|
FROM INFORMATION_SCHEMA.COLUMNS
|
|
WHERE COLUMN_NAME = '_IDRRef' AND TABLE_NAME LIKE @table_like;
|
|
EXEC sp_executesql @sql, N'@id binary(16)', @id=@id;
|
|
"@
|
|
$null = $command.Parameters.Add("@p", [System.Data.SqlDbType]::Binary, 16)
|
|
$command.Parameters["@p"].Value = $IdBytes
|
|
$null = $command.Parameters.Add("@table_like", [System.Data.SqlDbType]::NVarChar, 128)
|
|
$command.Parameters["@table_like"].Value = $TableLike
|
|
$reader = $command.ExecuteReader()
|
|
$tables = New-Object System.Collections.Generic.List[string]
|
|
try {
|
|
do {
|
|
while ($reader.Read()) {
|
|
$tables.Add([string]$reader.GetValue(0))
|
|
}
|
|
} while ($reader.NextResult())
|
|
}
|
|
finally {
|
|
$reader.Close()
|
|
$command.Dispose()
|
|
}
|
|
return [string[]]$tables.ToArray()
|
|
}
|
|
|
|
function Get-TableLikeForKind {
|
|
param([string]$Kind)
|
|
switch ($Kind) {
|
|
"Catalog" { return "_Reference%" }
|
|
"Document" { return "_Document%" }
|
|
"Enum" { return "_Enum%" }
|
|
default { return "%" }
|
|
}
|
|
}
|
|
|
|
function Get-RouteByTable {
|
|
param([hashtable]$TableIndex, [string]$Table)
|
|
if ($TableIndex.ContainsKey($Table)) {
|
|
return $TableIndex[$Table]
|
|
}
|
|
$match = [regex]::Match($Table, "^(_Reference|_Document|_Enum)(\d+)X\d+$")
|
|
if ($match.Success) {
|
|
$baseTable = "$($match.Groups[1].Value)$($match.Groups[2].Value)"
|
|
if ($TableIndex.ContainsKey($baseTable)) {
|
|
$route = $TableIndex[$baseTable]
|
|
return [pscustomobject]@{
|
|
kind = $route.kind
|
|
name = $route.name
|
|
guid = $route.guid
|
|
table = $Table
|
|
base_table = $baseTable
|
|
storage_role = $route.storage_role
|
|
sql_number = $route.sql_number
|
|
source = "extension_table_suffix"
|
|
}
|
|
}
|
|
}
|
|
return $null
|
|
}
|
|
|
|
function New-TargetIndex {
|
|
param([object]$RouteIndex)
|
|
|
|
$targets = @{}
|
|
foreach ($entry in $RouteIndex.objects.PSObject.Properties) {
|
|
$guid = [string]$entry.Name
|
|
$object = $entry.Value
|
|
foreach ($top in @($object.xml_top_objects)) {
|
|
if (-not (Test-HasProperty $top "xml_kind") -or -not (Test-HasProperty $top "name")) { continue }
|
|
$kind = [string]$top.xml_kind
|
|
$name = [string]$top.name
|
|
$storageRole = Get-StorageRole $kind
|
|
if (-not $storageRole) { continue }
|
|
$route = @($object.dbnames | Where-Object { $_.storage_role -eq $storageRole } | Select-Object -First 1)
|
|
if ($route.Count -eq 0) { continue }
|
|
$table = Get-PhysicalTable -Kind $kind -SqlNumber ([int]$route[0].sql_number)
|
|
if (-not $table) { continue }
|
|
$key = "$kind|$name"
|
|
$isBaseConfig = (Test-HasProperty $top "relative_path") -and ([string]$top.relative_path -notlike "*\*\\*")
|
|
$candidate = [pscustomobject]@{
|
|
kind = $kind
|
|
name = $name
|
|
guid = $guid
|
|
synonym = if (Test-HasProperty $top "synonym") { $top.synonym } else { $null }
|
|
relative_path = if (Test-HasProperty $top "relative_path") { $top.relative_path } else { $null }
|
|
storage_role = $storageRole
|
|
sql_number = [int]$route[0].sql_number
|
|
table = $table
|
|
source_file = $route[0].source_file
|
|
base_config_score = if ($isBaseConfig) { 1 } else { 0 }
|
|
}
|
|
if (-not $targets.ContainsKey($key)) {
|
|
$targets[$key] = $candidate
|
|
} elseif ($candidate.base_config_score -gt $targets[$key].base_config_score) {
|
|
$targets[$key] = $candidate
|
|
}
|
|
}
|
|
}
|
|
return $targets
|
|
}
|
|
|
|
function New-TableIndex {
|
|
param([hashtable]$TargetIndex)
|
|
$tables = @{}
|
|
foreach ($entry in $TargetIndex.GetEnumerator()) {
|
|
$target = $entry.Value
|
|
if ($target.table -and -not $tables.ContainsKey($target.table)) {
|
|
$tables[$target.table] = $target
|
|
}
|
|
}
|
|
return $tables
|
|
}
|
|
|
|
function Add-ReferenceCells {
|
|
param(
|
|
[System.Collections.Generic.List[object]]$References,
|
|
[object[]]$Rows,
|
|
[string]$Scope,
|
|
[string]$TablePartName,
|
|
[string]$TablePartTable
|
|
)
|
|
|
|
for ($rowIndex = 0; $rowIndex -lt $Rows.Count; $rowIndex++) {
|
|
$row = $Rows[$rowIndex]
|
|
foreach ($cellProperty in $row.PSObject.Properties) {
|
|
$cell = $cellProperty.Value
|
|
if (-not (Test-HasProperty $cell "value_type") -or -not $cell.value_type) { continue }
|
|
if (-not (Test-HasProperty $cell.value_type "types")) { continue }
|
|
$types = @($cell.value_type.types)
|
|
if ($types.Count -ne 1) { continue }
|
|
$typeName = [string]$types[0]
|
|
$match = [regex]::Match($typeName, "^cfg:(CatalogRef|DocumentRef|EnumRef)\.(.+)$")
|
|
if (-not $match.Success) { continue }
|
|
if (-not (Test-HasProperty $cell "value") -or -not $cell.value) { continue }
|
|
if (-not (Test-HasProperty $cell.value "kind") -or $cell.value.kind -ne "binary") { continue }
|
|
if (-not (Test-HasProperty $cell.value "hex")) { continue }
|
|
$hex = [string]$cell.value.hex
|
|
if ($hex -eq "00000000000000000000000000000000") { continue }
|
|
$References.Add([pscustomobject]@{
|
|
scope = $Scope
|
|
table_part_name = $TablePartName
|
|
table_part_table = $TablePartTable
|
|
row_index = $rowIndex
|
|
cell_key = $cellProperty.Name
|
|
metadata_path = $cell.metadata_path
|
|
metadata_name = $cell.metadata_name
|
|
metadata_uuid = $cell.metadata_uuid
|
|
column = $cell.column
|
|
ref_type = $typeName
|
|
ref_kind = $match.Groups[1].Value
|
|
target_kind = Get-ReferenceKind $match.Groups[1].Value
|
|
target_name = $match.Groups[2].Value
|
|
id_hex = $hex
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
$readResult = Get-Content -LiteralPath $ReadResultPath -Raw -Encoding UTF8 | ConvertFrom-Json
|
|
$routeIndex = Get-Content -LiteralPath $RouteIndexPath -Raw -Encoding UTF8 | ConvertFrom-Json
|
|
$targetIndex = New-TargetIndex $routeIndex
|
|
$tableIndex = New-TableIndex $targetIndex
|
|
|
|
$references = New-Object System.Collections.Generic.List[object]
|
|
Add-ReferenceCells -References $references -Rows @($readResult.main.rows) -Scope "main" -TablePartName $null -TablePartTable $readResult.main.table
|
|
foreach ($part in @($readResult.table_parts)) {
|
|
Add-ReferenceCells -References $references -Rows @($part.rows) -Scope "table_part" -TablePartName $part.name -TablePartTable $part.table
|
|
}
|
|
|
|
$connectionString = "Server=$Server;Database=$Database;User ID=$User;Password=$Password;Encrypt=False;TrustServerCertificate=True;Application Name=Codex 1C SQL Reference Resolver;"
|
|
$connection = [System.Data.SqlClient.SqlConnection]::new($connectionString)
|
|
$tableColumnCache = @{}
|
|
$resolved = New-Object System.Collections.Generic.List[object]
|
|
$targetMisses = 0
|
|
$rowMisses = 0
|
|
$resolvedCount = 0
|
|
$alternateHitCount = 0
|
|
|
|
try {
|
|
$connection.Open()
|
|
foreach ($reference in [object[]]$references.ToArray()) {
|
|
$targetKey = "$($reference.target_kind)|$($reference.target_name)"
|
|
$target = if ($targetIndex.ContainsKey($targetKey)) { $targetIndex[$targetKey] } else { $null }
|
|
if (-not $target) {
|
|
$targetMisses += 1
|
|
$resolved.Add([pscustomobject]@{
|
|
reference = $reference
|
|
target = $null
|
|
found = $false
|
|
reason = "target_metadata_not_found"
|
|
values = $null
|
|
})
|
|
continue
|
|
}
|
|
if (-not $tableColumnCache.ContainsKey($target.table)) {
|
|
$tableColumnCache[$target.table] = Get-Columns -Connection $connection -Table $target.table
|
|
}
|
|
$columns = Select-PresentationColumns -Kind $target.kind -Columns $tableColumnCache[$target.table]
|
|
$idBytes = Convert-HexToBytes $reference.id_hex
|
|
$row = Resolve-ReferenceRow -Connection $connection -Table $target.table -Columns $columns -IdBytes $idBytes
|
|
$alternateHits = @()
|
|
if (-not $row.found) {
|
|
$hitTables = Find-IdTables -Connection $connection -TableLike (Get-TableLikeForKind $target.kind) -IdBytes $idBytes
|
|
$alternateRows = New-Object System.Collections.Generic.List[object]
|
|
foreach ($hitTable in @($hitTables | Where-Object { $_ -ne $target.table })) {
|
|
if (-not $tableColumnCache.ContainsKey($hitTable)) {
|
|
$tableColumnCache[$hitTable] = Get-Columns -Connection $connection -Table $hitTable
|
|
}
|
|
$hitColumns = Select-PresentationColumns -Kind $target.kind -Columns $tableColumnCache[$hitTable]
|
|
$hitRow = Resolve-ReferenceRow -Connection $connection -Table $hitTable -Columns $hitColumns -IdBytes $idBytes
|
|
$alternateRows.Add([pscustomobject]@{
|
|
table = $hitTable
|
|
route = Get-RouteByTable -TableIndex $tableIndex -Table $hitTable
|
|
found = $hitRow.found
|
|
values = $hitRow.values
|
|
})
|
|
}
|
|
$alternateHits = [object[]]$alternateRows.ToArray()
|
|
$alternateHitCount += $alternateHits.Count
|
|
}
|
|
if ($row.found) { $resolvedCount += 1 } else { $rowMisses += 1 }
|
|
$resolved.Add([pscustomobject]@{
|
|
reference = $reference
|
|
target = $target
|
|
found = $row.found
|
|
reason = $row.reason
|
|
values = $row.values
|
|
alternate_hits = $alternateHits
|
|
})
|
|
}
|
|
|
|
$result = [ordered]@{
|
|
schema = "onec_sql_reference_resolution.v1"
|
|
read_result_path = (Resolve-Path -LiteralPath $ReadResultPath).ProviderPath
|
|
route_index_path = (Resolve-Path -LiteralPath $RouteIndexPath).ProviderPath
|
|
server = $Server
|
|
database = $Database
|
|
source = [pscustomobject]@{
|
|
kind = $readResult.kind
|
|
identity = $readResult.identity
|
|
}
|
|
summary = [pscustomobject]@{
|
|
reference_cells = $references.Count
|
|
resolved = $resolvedCount
|
|
target_metadata_misses = $targetMisses
|
|
row_misses = $rowMisses
|
|
alternate_hits = $alternateHitCount
|
|
}
|
|
references = [object[]]$resolved.ToArray()
|
|
}
|
|
|
|
$outputDirectory = Split-Path -Parent $OutputPath
|
|
if ($outputDirectory) {
|
|
New-Item -ItemType Directory -Force -Path $outputDirectory | Out-Null
|
|
}
|
|
$result | ConvertTo-Json -Depth 100 | Set-Content -LiteralPath $OutputPath -Encoding UTF8
|
|
|
|
[pscustomobject]@{
|
|
output = (Resolve-Path -LiteralPath $OutputPath).ProviderPath
|
|
reference_cells = $references.Count
|
|
resolved = $resolvedCount
|
|
target_metadata_misses = $targetMisses
|
|
row_misses = $rowMisses
|
|
alternate_hits = $alternateHitCount
|
|
} | ConvertTo-Json -Depth 10
|
|
}
|
|
finally {
|
|
$connection.Close()
|
|
$connection.Dispose()
|
|
}
|