private void ImportDependencyProviders(Dtf.Database db)
{
if (db.Tables.Contains("WixDependencyProvider"))
{
string query = "SELECT `ProviderKey`, `Version`, `DisplayName`, `Attributes` FROM `WixDependencyProvider`";
using (Dtf.View view = db.OpenView(query))
{
view.Execute();
while (true)
{
using (Dtf.Record record = view.Fetch())
{
if (null == record)
{
break;
}
// Import the provider key and attributes.
string providerKey = record.GetString(1);
string version = record.GetString(2) ?? this.Facade.MsiPackage.ProductVersion;
string displayName = record.GetString(3) ?? this.Facade.Package.DisplayName;
int attributes = record.GetInteger(4);
ProvidesDependency dependency = new ProvidesDependency(providerKey, version, displayName, attributes);
dependency.Imported = true;
this.Facade.Provides.Add(dependency);
}
}
}
}
}
private void CreateRelatedPackages(Dtf.Database db)
{
// Represent the Upgrade table as related packages.
if (db.Tables.Contains("Upgrade"))
{
using (Dtf.View view = db.OpenView("SELECT `UpgradeCode`, `VersionMin`, `VersionMax`, `Language`, `Attributes` FROM `Upgrade`"))
{
view.Execute();
while (true)
{
using (Dtf.Record record = view.Fetch())
{
if (null == record)
{
break;
}
WixBundleRelatedPackageRow related = (WixBundleRelatedPackageRow)this.RelatedPackageTable.CreateRow(this.Facade.Package.SourceLineNumbers);
related.ChainPackageId = this.Facade.Package.WixChainItemId;
related.Id = record.GetString(1);
related.MinVersion = record.GetString(2);
related.MaxVersion = record.GetString(3);
related.Languages = record.GetString(4);
int attributes = record.GetInteger(5);
related.OnlyDetect = (attributes & MsiInterop.MsidbUpgradeAttributesOnlyDetect) == MsiInterop.MsidbUpgradeAttributesOnlyDetect;
related.MinInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesVersionMinInclusive) == MsiInterop.MsidbUpgradeAttributesVersionMinInclusive;
related.MaxInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive) == MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive;
related.LangInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesLanguagesExclusive) == 0;
}
}
}
}
}
/// <summary>
/// Query an MSI table for all records
/// </summary>
/// <param name="msi">The path to an MSI</param>
/// <param name="sql">An MSI query</param>
/// <returns>A list of records is returned</returns>
/// <remarks>Uses DTF</remarks>
public static List <DTF.Record> QueryAllRecords(string msi, string query)
{
List <DTF.Record> result = new List <DTF.Record>();
using (DTF.Database database = new DTF.Database(msi, DTF.DatabaseOpenMode.ReadOnly))
{
using (DTF.View view = database.OpenView(query, null))
{
view.Execute();
DTF.Record record = null;
while (null != (record = view.Fetch()))
{
// Copy record created by Fetch to record created manually to remove View reference
DTF.Record copyRecord = new DTF.Record(record.FieldCount);
for (int i = 0; i <= record.FieldCount; i++)
{
copyRecord[i] = record[i];
}
record.Close();
result.Add(copyRecord);
}
}
}
return(result);
}
/// <summary>
/// Executes the specified SQL SELECT query and returns a single result.
/// </summary>
/// <param name="sql">SQL SELECT query string</param>
/// <param name="record">Optional Record object containing the values that replace
/// the parameter tokens (?) in the SQL query.</param>
/// <returns>First field of the first result</returns>
/// <exception cref="BadQuerySyntaxException">the SQL syntax is invalid</exception>
/// <exception cref="InstallerException">the View could not be executed
/// or the query returned 0 results</exception>
/// <exception cref="InvalidHandleException">the Database handle is invalid</exception>
/// <remarks><p>
/// Win32 MSI APIs:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msidatabaseopenview.asp">MsiDatabaseOpenView</a>,
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewexecute.asp">MsiViewExecute</a>,
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewfetch.asp">MsiViewFetch</a>
/// </p></remarks>
public object ExecuteScalar(string sql, Record record)
{
if (String.IsNullOrEmpty(sql))
{
throw new ArgumentNullException("sql");
}
View view = this.OpenView(sql);
Record rec = null;
try
{
view.Execute(record);
rec = view.Fetch();
if (rec == null)
{
throw InstallerException.ExceptionFromReturnCode((uint)NativeMethods.Error.NO_MORE_ITEMS);
}
return(rec[1]);
}
finally
{
if (rec != null)
{
rec.Close();
}
view.Close();
}
}
public void DeleteRecord()
{
string dbFile = "DeleteRecord.msi";
using (Database db = new Database(dbFile, DatabaseOpenMode.CreateDirect))
{
WindowsInstallerUtils.InitializeProductDatabase(db);
WindowsInstallerUtils.CreateTestProduct(db);
string query = "SELECT `Property`, `Value` FROM `Property` WHERE `Property` = 'UpgradeCode'";
using (View view = db.OpenView(query))
{
view.Execute();
Record rec = view.Fetch();
Console.WriteLine("Calling ToString() : " + rec);
view.Delete(rec);
}
Assert.AreEqual(0, db.ExecuteStringQuery(query).Count);
}
}
/// <summary>
/// Checks whether a table contains a persistent column with a given name.
/// </summary>
/// <param name="table">The table to the checked</param>
/// <param name="column">The name of the column to be checked</param>
/// <returns>true if the column exists in the table; false if the column is temporary or does not exist.</returns>
/// <exception cref="InstallerException">the View could not be executed</exception>
/// <exception cref="InvalidHandleException">the Database handle is invalid</exception>
/// <remarks><p>
/// To check whether a column exists regardless of persistence,
/// use <see cref="ColumnCollection.Contains"/>.
/// </p></remarks>
public bool IsColumnPersistent(string table, string column)
{
if (String.IsNullOrEmpty(table))
{
throw new ArgumentNullException("table");
}
if (String.IsNullOrEmpty(column))
{
throw new ArgumentNullException("column");
}
using (View view = this.OpenView(
"SELECT `Number` FROM `_Columns` WHERE `Table` = '{0}' AND `Name` = '{1}'", table, column))
{
view.Execute();
using (Record rec = view.Fetch())
{
return(rec != null);
}
}
}
private long ImportExternalFileAsPayloadsAndReturnInstallSize(Dtf.Database db, WixBundlePayloadRow packagePayload, bool longNamesInImage, bool compressed, ISet <string> payloadNames)
{
long size = 0;
if (db.Tables.Contains("Component") && db.Tables.Contains("Directory") && db.Tables.Contains("File"))
{
Hashtable directories = new Hashtable();
// Load up the directory hash table so we will be able to resolve source paths
// for files in the MSI database.
using (Dtf.View view = db.OpenView("SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"))
{
view.Execute();
while (true)
{
using (Dtf.Record record = view.Fetch())
{
if (null == record)
{
break;
}
string sourceName = Installer.GetName(record.GetString(3), true, longNamesInImage);
directories.Add(record.GetString(1), new ResolvedDirectory(record.GetString(2), sourceName));
}
}
}
// Resolve the source paths to external files and add each file size to the total
// install size of the package.
using (Dtf.View view = db.OpenView("SELECT `Directory_`, `File`, `FileName`, `File`.`Attributes`, `FileSize` FROM `Component`, `File` WHERE `Component`.`Component`=`File`.`Component_`"))
{
view.Execute();
while (true)
{
using (Dtf.Record record = view.Fetch())
{
if (null == record)
{
break;
}
// Skip adding the loose files as payloads if it was suppressed.
if (!this.Facade.MsiPackage.SuppressLooseFilePayloadGeneration)
{
// If the file is explicitly uncompressed or the MSI is uncompressed and the file is not
// explicitly marked compressed then this is an external file.
if (MsiInterop.MsidbFileAttributesNoncompressed == (record.GetInteger(4) & MsiInterop.MsidbFileAttributesNoncompressed) ||
(!compressed && 0 == (record.GetInteger(4) & MsiInterop.MsidbFileAttributesCompressed)))
{
string fileSourcePath = Binder.GetFileSourcePath(directories, record.GetString(1), record.GetString(3), compressed, longNamesInImage);
string name = Path.Combine(Path.GetDirectoryName(packagePayload.Name), fileSourcePath);
if (!payloadNames.Contains(name))
{
string generatedId = Common.GenerateIdentifier("f", packagePayload.Id, record.GetString(2));
string payloadSourceFile = FileManager.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, fileSourcePath, "File", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
WixBundlePayloadRow payload = (WixBundlePayloadRow)this.PayloadTable.CreateRow(this.Facade.Package.SourceLineNumbers);
payload.Id = generatedId;
payload.Name = name;
payload.SourceFile = payloadSourceFile;
payload.Compressed = packagePayload.Compressed;
payload.UnresolvedSourceFile = name;
payload.Package = packagePayload.Package;
payload.Container = packagePayload.Container;
payload.ContentFile = true;
payload.EnableSignatureValidation = packagePayload.EnableSignatureValidation;
payload.Packaging = packagePayload.Packaging;
payload.ParentPackagePayload = packagePayload.Id;
}
}
}
size += record.GetInteger(5);
}
}
}
}
return(size);
}
private void CreateMsiFeatures(Dtf.Database db)
{
if (db.Tables.Contains("Feature"))
{
using (Dtf.View featureView = db.OpenView("SELECT `Component_` FROM `FeatureComponents` WHERE `Feature_` = ?"))
using (Dtf.View componentView = db.OpenView("SELECT `FileSize` FROM `File` WHERE `Component_` = ?"))
{
using (Dtf.Record featureRecord = new Dtf.Record(1))
using (Dtf.Record componentRecord = new Dtf.Record(1))
{
using (Dtf.View allFeaturesView = db.OpenView("SELECT * FROM `Feature`"))
{
allFeaturesView.Execute();
while (true)
{
using (Dtf.Record allFeaturesResultRecord = allFeaturesView.Fetch())
{
if (null == allFeaturesResultRecord)
{
break;
}
string featureName = allFeaturesResultRecord.GetString(1);
// Calculate the Feature size.
featureRecord.SetString(1, featureName);
featureView.Execute(featureRecord);
// Loop over all the components for the feature to calculate the size of the feature.
long size = 0;
while (true)
{
using (Dtf.Record componentResultRecord = featureView.Fetch())
{
if (null == componentResultRecord)
{
break;
}
string component = componentResultRecord.GetString(1);
componentRecord.SetString(1, component);
componentView.Execute(componentRecord);
while (true)
{
using (Dtf.Record fileResultRecord = componentView.Fetch())
{
if (null == fileResultRecord)
{
break;
}
string fileSize = fileResultRecord.GetString(1);
size += Convert.ToInt32(fileSize, CultureInfo.InvariantCulture.NumberFormat);
}
}
}
}
WixBundleMsiFeatureRow feature = (WixBundleMsiFeatureRow)this.MsiFeatureTable.CreateRow(this.Facade.Package.SourceLineNumbers);
feature.ChainPackageId = this.Facade.Package.WixChainItemId;
feature.Name = featureName;
feature.Parent = allFeaturesResultRecord.GetString(2);
feature.Title = allFeaturesResultRecord.GetString(3);
feature.Description = allFeaturesResultRecord.GetString(4);
feature.Display = allFeaturesResultRecord.GetInteger(5);
feature.Level = allFeaturesResultRecord.GetInteger(6);
feature.Directory = allFeaturesResultRecord.GetString(7);
feature.Attributes = allFeaturesResultRecord.GetInteger(8);
feature.Size = size;
}
}
}
}
}
}
}
