public override string GetPath()
{
return(String.Format(
"{0}/{1}",
Id.ToLowerInvariant(),
SemanticVersionExtensions.Normalize(Version).ToLowerInvariant()));
}
public override void ExecuteCommand()
{
WithConnection((c, db) =>
{
Log.Trace("Collecting list of packages...");
var packages = db.Query <Package>(@"
SELECT pr.Id, p.[Key], p.Version
FROM Packages p
INNER JOIN PackageRegistrations pr ON pr.[Key] = p.PackageRegistrationKey
WHERE p.NormalizedVersion IS NULL")
.ToList();
Log.Trace("Collected {0} packages", packages.Count);
DataTable output;
int count = 0;
WithTableType(c, "Temp_NormalizePackageVersionsInputType", "PackageKey int, NormalizedVersion nvarchar(64)", () =>
{
// Build a table to hold the new data
var updateTable = new DataTable();
updateTable.Columns.Add(new DataColumn("PackageKey", typeof(int)));
updateTable.Columns.Add(new DataColumn("NormalizedVersion", typeof(string)));
foreach (var package in packages)
{
string normalized = SemanticVersionExtensions.Normalize(package.Version);
var row = updateTable.NewRow();
row.SetField("PackageKey", package.Key);
row.SetField("NormalizedVersion", normalized);
updateTable.Rows.Add(row);
}
// Run the query with the table parameter
var cmd = c.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = WhatIf ? WhatIfQuery : CommitQuery;
cmd.Parameters.Add(new SqlParameter("@updateTable", SqlDbType.Structured)
{
TypeName = "Temp_NormalizePackageVersionsInputType",
Value = updateTable
});
Log.Trace("Updating Database...");
var reader = cmd.ExecuteReader();
Log.Trace("Database Update Complete");
// Load the results into a datatable and render them
output = new DataTable();
output.Load(reader);
foreach (var row in output.Rows.Cast <DataRow>())
{
string version = row.Field <string>("Version");
string normalized = row.Field <string>("NormalizedVersion");
if (!String.Equals(version, normalized, StringComparison.Ordinal))
{
count++;
}
}
Log.Info("Updated {0} packages", count);
});
});
}
private static Tuple <Target, string> ExtractComparison(MethodCallExpression outerWhere)
{
// We expect to see an expression that looks like this:
// Queryable.Where(<nested expression>, p => <constant> == p.<property>);
var arg = Unquote(outerWhere.Arguments[1]);
if (arg.NodeType != ExpressionType.Lambda)
{
return(null);
}
var lambda = arg as LambdaExpression; // p => <constant> == p.<property>
if (lambda.Body.NodeType != ExpressionType.Equal)
{
return(null);
}
var binExpr = lambda.Body as BinaryExpression; // <constant> == p.<property>
// Get the two sides, we don't care which side is left and which is right.
ConstantExpression constSide = (binExpr.Left as ConstantExpression) ?? (binExpr.Right as ConstantExpression);
if (constSide == null || constSide.Type != typeof(string))
{
return(null);
}
MemberExpression memberSide = (binExpr.Right as MemberExpression) ?? (binExpr.Left as MemberExpression);
if (memberSide == null)
{
return(null);
}
// Check if it's a known member comparison
if (memberSide.Member == _normalizedVersionMember)
{
return(Tuple.Create(Target.Version, (string)constSide.Value));
}
else if (memberSide.Member == _versionMember)
{
return(Tuple.Create(Target.Version, SemanticVersionExtensions.Normalize((string)constSide.Value)));
}
else if (memberSide.Member == _idMember)
{
return(Tuple.Create(Target.Id, (string)constSide.Value));
}
return(null);
}
public override void ExecuteCommand()
{
using (var sqlConnection = new SqlConnection(ConnectionString.ConnectionString))
using (var dbExecutor = new SqlExecutor(sqlConnection))
{
sqlConnection.Open();
// Query for packages
Log.Info("Gathering list of packages...");
var packages = dbExecutor.Query <PackageSummary>(@"
SELECT p.[Key], p.PackageRegistrationKey, r.Id, p.Version, p.Hash, p.LastUpdated, p.Published, p.Listed, p.IsLatestStable
FROM Packages p
INNER JOIN PackageRegistrations r ON p.PackageRegistrationKey = r.[Key]");
// Group by Id and and SemVer
Log.Info("Grouping by Package ID and Actual Version...");
var groups = packages.GroupBy(p => new { p.Id, Version = SemanticVersionExtensions.Normalize(p.Version) });
// Find any groups with more than one entry
Log.Info("Finding Duplicates...");
var dups = groups.Where(g => g.Count() > 1);
// Print them out
int dupsUnlistedCount = 0;
int latestCount = 0;
foreach (var dup in dups)
{
ProcessDuplicate(dup.Key.Id, dup.Key.Version, dup.ToList(), ref dupsUnlistedCount, ref latestCount);
}
var totalDupes = dups.Count();
Log.Info("Found {0} Packages with duplicates.", totalDupes);
Log.Info(" {0} of them have no listed duplicates.", dupsUnlistedCount);
Log.Info(" {0} of them have multiple listed duplicates.", totalDupes - dupsUnlistedCount);
if (latestCount > 0)
{
Log.Warn(" {0} of them are the latest version of the relevant package", latestCount);
}
else
{
Log.Info(" NONE of them are the latest version of the relevant package");
}
}
}