private static DatabasePackage AddPackage(string name, string owner)
{
var pack = new DatabasePackage();
pack.Name = name;
pack.SchemaOwner = owner;
return pack;
}
private void CreateResult(ResultType resultType, DatabasePackage package, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Package,
ResultType = resultType,
Name = package.Name,
SchemaOwner = package.SchemaOwner,
Script = script
};
_results.Add(result);
}
private static DatabasePackage FindPackage(DatabaseSchema databaseSchema, string name, string owner)
{
var package = databaseSchema.Packages.Find(
t2 => t2.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (package == null)
{
package = new DatabasePackage();
package.Name = name;
package.SchemaOwner = owner;
databaseSchema.Packages.Add(package);
}
return(package);
}
private static void UpdatePackages(DatabaseSchema databaseSchema)
{
var deletedSprocs = new List <DatabaseStoredProcedure>();
var deletedFuncs = new List <DatabaseFunction>();
//find stored procedures that are in packages
databaseSchema.StoredProcedures.ForEach(delegate(DatabaseStoredProcedure sproc)
{
string name = sproc.Package;
if (name == null)
{
return;
}
DatabasePackage package = FindPackage(databaseSchema, name, sproc.SchemaOwner);
if (!package.StoredProcedures.Contains(sproc))
{
package.StoredProcedures.Add(sproc);
deletedSprocs.Add(sproc);
}
});
databaseSchema.Functions.ForEach(delegate(DatabaseFunction function)
{
string name = function.Package;
if (name == null)
{
return;
}
DatabasePackage package = FindPackage(databaseSchema, name, function.SchemaOwner);
if (!package.Functions.Contains(function))
{
package.Functions.Add(function);
deletedSprocs.Add(function);
}
});
foreach (var deletedSproc in deletedSprocs)
{
//has been moved into a package
databaseSchema.StoredProcedures.Remove(deletedSproc);
}
foreach (var deletedFunc in deletedFuncs)
{
//has been moved into a package
databaseSchema.Functions.Remove(deletedFunc);
}
}
public override string AddPackage(DatabasePackage databasePackage)
{
if (string.IsNullOrEmpty(databasePackage.Definition) || string.IsNullOrEmpty(databasePackage.Body))
{
return "-- add package " + databasePackage.Name + " (no sql available)";
}
//the body and defintion starts "PACKAGE name AS", so just add CREATE OR REPLACE
return string.Format(CultureInfo.InvariantCulture,
@"CREATE OR REPLACE
{0}
/
CREATE OR REPLACE
{1}
/
",
databasePackage.Definition,
databasePackage.Body);
}
public static List<DatabasePackage> Packages(DataTable dt)
{
List<DatabasePackage> list = new List<DatabasePackage>();
if (dt.Rows.Count == 0) return list;
//oracle and ODP
string key = "OBJECT_NAME";
string ownerKey = "OWNER";
//Devart.Data.Oracle
if (!dt.Columns.Contains(key)) key = "NAME";
if (!dt.Columns.Contains(ownerKey)) ownerKey = "SCHEMA";
foreach (DataRow row in dt.Rows)
{
DatabasePackage package = new DatabasePackage();
package.Name = row[key].ToString();
package.SchemaOwner = row[ownerKey].ToString();
list.Add(package);
}
return list;
}
public virtual string AddPackage(DatabasePackage databasePackage)
{
return null; //only applies to Oracle, so see it's override
}
private static DatabasePackage FindPackage(DatabaseSchema databaseSchema, string name, string owner)
{
var package = databaseSchema.Packages.Find(
t2 => t2.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (package == null)
{
package = new DatabasePackage();
package.Name = name;
package.SchemaOwner = owner;
databaseSchema.Packages.Add(package);
}
return package;
}
public string AddPackage(DatabasePackage package)
{
return _migration.AddPackage(package);
}
public string DropPackage(DatabasePackage package)
{
return _migration.DropPackage(package);
}
private void MoveStoredProceduresIntoPackages(List<DatabasePackage> packs, List<DatabaseStoredProcedure> sprocs, IFilter packFilter)
{
var packSprocs = sprocs.Where(x => !string.IsNullOrEmpty(x.Package)).ToList();
if (packSprocs.Count == 0) return;
var packList = packSprocs.Select(x => x.Package).Distinct();
foreach (var packName in packList)
{
if (packFilter.Exclude(packName)) continue;
var packContents = sprocs.Where(x => x.Package == packName).ToList();
var package = packs.FirstOrDefault(x => string.Equals(x.Name, packName));
if (package == null)
{
package = new DatabasePackage { Name = packName };
}
package.StoredProcedures.AddRange(packContents);
_databaseSchema.Packages.Add(package);
}
sprocs.RemoveAll(x => !string.IsNullOrEmpty(x.Package));
}
private void WritePackage(DatabasePackage package, string directoryFullName, ProjectWriter pw)
{
//we'll put stored procedures in subdirectory
var packDirectory = new DirectoryInfo(Path.Combine(directoryFullName, package.NetName));
if (!packDirectory.Exists) packDirectory.Create();
var ns = _codeWriterSettings.Namespace;
if (!string.IsNullOrEmpty(ns)) ns += "." + package.NetName;
foreach (var sproc in package.StoredProcedures)
{
WriteStoredProcedure(package.NetName, packDirectory.FullName, ns, sproc, pw);
}
}
public override string DropPackage(DatabasePackage databasePackage)
{
return "DROP PACKAGE " + SchemaPrefix(databasePackage.SchemaOwner) + Escape(databasePackage.Name) + ";";
}
public void BuildPackage(DatabasePackage package)
{
try
{
var txt = _migrationGenerator.AddPackage(package);
Clipboard.SetText(txt, TextDataFormat.UnicodeText);
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message);
}
}
