/// <summary>
/// Returns a database object identified by its composite string id.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public DatabaseObject GetDatabaseObjectByKey(string key)
{
string[] parts = key.Split('|');
DatabaseObjectType type = GetDatabaseObjectTypeFromKey(key);
switch (type)
{
case DatabaseObjectType.Table:
return(this.Datasets[parts[1]].Tables[parts[2], parts[3], parts[4]]);
case DatabaseObjectType.View:
return(this.Datasets[parts[1]].Views[parts[2], parts[3], parts[4]]);
case DatabaseObjectType.TableValuedFunction:
case DatabaseObjectType.SqlTableValuedFunction:
case DatabaseObjectType.ClrTableValuedFunction:
return(this.Datasets[parts[1]].TableValuedFunctions[parts[2], parts[3], parts[4]]);
case DatabaseObjectType.ScalarFunction:
case DatabaseObjectType.SqlScalarFunction:
case DatabaseObjectType.ClrScalarFunction:
return(this.Datasets[parts[1]].ScalarFunctions[parts[2], parts[3], parts[4]]);
case DatabaseObjectType.StoredProcedure:
case DatabaseObjectType.SqlStoredProcedure:
case DatabaseObjectType.ClrStoredProcedure:
return(this.Datasets[parts[1]].StoredProcedures[parts[2], parts[3], parts[4]]);
default:
throw new NotImplementedException();
}
}
private TreeNodeCollection AddTreeNodes <T>(TreeNode node, DatabaseObjectType types, DatabaseObjectType type, List <T> dbObjects, bool createFolderNode = true, bool createFakeNode = false)
where T : DatabaseObject
{
TreeNode targetNode = node;
if (types.HasFlag(type))
{
if (createFolderNode)
{
targetNode = node.AddDbObjectFolderNode(dbObjects);
}
else
{
targetNode = node.AddDbObjectNodes(dbObjects);
}
}
if (createFakeNode && targetNode != null)
{
foreach (TreeNode child in targetNode.Nodes)
{
child.Nodes.Add(DbObjectsTreeHelper.CreateFakeNode());
}
}
return(node.Nodes);
}
public DatabaseObject(int id, string schema, string name, DatabaseObjectType type)
{
ID = id;
Schema = schema;
Name = name;
Type = type;
}
private void btnOK_Click(object sender, EventArgs e)
{
DatabaseObjectType databaseObjectType = DatabaseObjectType.None;
foreach (var item in this.chkDbObjectTypes.CheckedItems)
{
DatabaseObjectType type = (DatabaseObjectType)Enum.Parse(typeof(DatabaseObjectType), ManagerUtil.GetSingularString(item.ToString()));
databaseObjectType = databaseObjectType | type;
}
if (databaseObjectType == DatabaseObjectType.None)
{
MessageBox.Show("Please select database object type.");
return;
}
else
{
this.DatabaseObjectType = databaseObjectType;
}
this.DialogResult = DialogResult.OK;
this.Close();
}
public override string GetObjectUniqueKey(DatabaseObjectType objectType, string datasetName, string databaseName, string schemaName, string objectName)
{
// MySQL doesn't have the equivalent of schemas of SQL Server.
schemaName = String.Empty;
return(base.GetObjectUniqueKey(objectType, datasetName, databaseName, schemaName, objectName));
}
public DatabaseObject(DatabaseObjectType type, byte[] content)
{
if (content == null) { throw new ArgumentNullException("content"); }
Type = type;
Content = content;
}
/// <summary>根据DatabaseObjectType获取某个数据库下所有sqlServer数据库查询对象信息语句
/// 根据DatabaseObjectType获取某个数据库下所有sqlServer数据库查询对象信息语句
/// </summary>
/// <param name="strDbName">strDBName</param>
/// <param name="objType">objType</param>
/// <returns>返回查询表/视图/存储过程/函数等信息的语句</returns>
private static string GetSqlServerObjectSql(string strDbName, DatabaseObjectType objType)
{
string strSql = string.Empty;
switch (objType)
{
case DatabaseObjectType.Table:
strSql = " USE [" + strDbName + "] SELECT '" + strDbName + "' as DBName, name , 'Table' as Type FROM dbo.sysobjects where OBJECTPROPERTY(id, N'IsUserTable') = 1 ORDER BY Name ";
break;
case DatabaseObjectType.Procedure:
strSql = " USE [" + strDbName + "] SELECT '" + strDbName + "' as DBName, Name ,object_definition(OBJECT_ID) AS ObjectContent,'PROCEDURE' as Type FROM sys.procedures ORDER BY NAME ";
break;
case DatabaseObjectType.View:
strSql = " USE [" + strDbName + "] SELECT '" + strDbName + "' as DBName, Name ,object_definition(OBJECT_ID) AS ObjectContent,'VIEW' as Type FROM sys.views ORDER BY Name ";
break;
case DatabaseObjectType.Function:
strSql = " USE [" + strDbName + "] SELECT '" + strDbName + "' as DBName,name , object_definition(ID) AS ObjectContent,'FUNCTION' as Type FROM sysobjects WHERE [type] IN (N'FN', N'IF', N'TF', N'FS', N'FT') AND category = 0 ORDER BY name ";
break;
case DatabaseObjectType.Trigger:
strSql = " USE [" + strDbName + "] SELECT '" + strDbName + "' as DBName, NAME ,object_definition(ID) AS ObjectContent, 'TRIGGER' AS Type FROM sysobjects WHERE TYPE='TR' ORDER BY Name ";
break;
}
return(strSql);
}
public frmTbls()
{
InitializeComponent();
DatabaseObjectTypeShown = DatabaseObjectType.Tables;
moDB = null;
moTbl = null;
}
private void FillOutDatabaseObjectNames(string cmdName, CheckedListBox clb, DatabaseObjectType objectType)
{
string objectName;
string strCmd = ConfigurationManager.AppSettings[cmdName];
Database db = DatabaseFactory.CreateDatabase();
Action beginUpdate = () => clb.BeginUpdate();
clb.Invoke(beginUpdate);
using (IDataReader reader = db.ExecuteReader(CommandType.Text, strCmd))
{
Action addItem;
while (reader.Read())
{
objectName = reader.GetString(0);
addItem = () => clb.Items.Add(new ListItem()
{
Value = objectName, Type = objectType
});
clb.Invoke(addItem);
}
}
Action endUpdate = () => clb.EndUpdate();
clb.Invoke(endUpdate);
}
private async Task AddDbObjectNodes(TreeNode parentNode, string database, DatabaseObjectType databaseObjectType = DatabaseObjectType.None, bool createFolderNode = true)
{
DbInterpreter dbInterpreter = this.GetDbInterpreter(database);
SchemaInfo schemaInfo = databaseObjectType == DatabaseObjectType.None ? new SchemaInfo() :
await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter()
{
DatabaseObjectType = databaseObjectType
});
this.ClearNodes(parentNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Table, schemaInfo.Tables, createFolderNode, true);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.View, schemaInfo.Views, createFolderNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Function, schemaInfo.Functions, createFolderNode);
this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Procedure, schemaInfo.Procedures, createFolderNode);
foreach (UserDefinedType userDefinedType in schemaInfo.UserDefinedTypes)
{
string text = $"{userDefinedType.Name}({userDefinedType.Type})";
string imageKeyName = nameof(userDefinedType);
TreeNode node = DbObjectsTreeHelper.CreateTreeNode(userDefinedType.Name, text, imageKeyName);
node.Tag = userDefinedType;
parentNode.Nodes.Add(node);
}
}
protected ScripterBase(ICollection objects, DatabaseObjectType objectType)
{
ObjectType = objectType;
Objects = objects;
OutputFolder = Path.Combine(Program.Options.OutputDirectory, objectType.ToString());
Filter = new Regex(Program.Options.Filter, RegexOptions.Compiled | RegexOptions.IgnoreCase);
ScriptOptionsDrop = new ScriptingOptions
{
ScriptDrops = true,
IncludeIfNotExists = true,
AllowSystemObjects = false,
NoCommandTerminator = false,
AgentJobId = false,
Statistics = false,
ContinueScriptingOnError = true
};
ScriptOptionsCreate = new ScriptingOptions
{
ScriptDrops = false,
SchemaQualify = true,
AllowSystemObjects = false,
NoCommandTerminator = false,
ContinueScriptingOnError = true
};
lock (SyncRoot)
{
if (OutputFolder.IndexOf("\\", System.StringComparison.Ordinal) > -1 && !Directory.Exists(OutputFolder))
Directory.CreateDirectory(OutputFolder);
}
}
private void DecorateData(List <DbDifference> differences)
{
Dictionary <DbObjectTreeFolderType, DbDifferenceType> folderTypes = new Dictionary <DbObjectTreeFolderType, DbDifferenceType>();
Action <DbObjectTreeFolderType, DbDifferenceType> addFolderType = (folderType, diffType) =>
{
if (!folderTypes.ContainsKey(folderType))
{
folderTypes.Add(folderType, diffType);
}
else if (diffType != DbDifferenceType.None)
{
folderTypes[folderType] = DbDifferenceType.Modified;
}
};
foreach (DbDifference difference in differences)
{
DatabaseObjectType databaseObjectType = difference.DatabaseObjectType;
switch (databaseObjectType)
{
case DatabaseObjectType.UserDefinedType:
difference.ParentType = DbObjectTreeFolderType.Types.ToString();
addFolderType(DbObjectTreeFolderType.Types, difference.DifferenceType);
break;
case DatabaseObjectType.Table:
difference.ParentType = DbObjectTreeFolderType.Tables.ToString();
addFolderType(DbObjectTreeFolderType.Tables, difference.DifferenceType);
break;
case DatabaseObjectType.View:
difference.ParentType = DbObjectTreeFolderType.Views.ToString();
addFolderType(DbObjectTreeFolderType.Views, difference.DifferenceType);
break;
case DatabaseObjectType.Function:
difference.ParentType = DbObjectTreeFolderType.Functions.ToString();
addFolderType(DbObjectTreeFolderType.Functions, difference.DifferenceType);
break;
case DatabaseObjectType.Procedure:
difference.ParentType = DbObjectTreeFolderType.Procedures.ToString();
addFolderType(DbObjectTreeFolderType.Procedures, difference.DifferenceType);
break;
}
}
int i = 0;
foreach (var kp in folderTypes)
{
differences.Insert(i++, new DbDifference()
{
Type = kp.Key.ToString(), DifferenceType = kp.Value
});
}
}
public Difference(bool isLeftDifferent, string name, DatabaseObjectType objectType, DifferenceOutcome outcome, ChangeRequired change)
{
this.IsLeftDifferent = isLeftDifferent;
this.Name = name;
this.ObjectType = objectType;
this.Outcome = outcome;
this.Change = change;
}
internal static IObjectMap CreateMap(DatabaseObjectType databaseObjectType, ICommandAdapter commandAdapter)
{
return(databaseObjectType switch
{
DatabaseObjectType.Table => new ObjectMap <T>(commandAdapter, databaseObjectType),
DatabaseObjectType.View => new ObjectMap <T>(commandAdapter, databaseObjectType),
_ => throw new InvalidOperationException("Unknown database object type.")
});
public DatabaseObject(DatabaseObjectType databaseObjectType, string schemaName, string objectName, string objectText, string parentObjectName = "")
{
DatabaseObjectType = databaseObjectType;
SchemaName = schemaName;
ObjectName = objectName;
ObjectText = objectText;
ParentObjectName = parentObjectName;
}
public Difference(bool isLeftDifferent, string name, DatabaseObjectType objectType, DifferenceOutcome outcome, ChangeRequired change)
{
this.IsLeftDifferent = isLeftDifferent;
this.Name = name;
this.ObjectType = objectType;
this.Outcome = outcome;
this.Change = change;
}
private string ReplaceTemplatePlaceHolders(string templateContent, DatabaseObjectType databaseObjectType, ScriptAction scriptAction)
{
templateContent = templateContent.Replace("$ACTION$", scriptAction.ToString())
.Replace("$NAME$", this.dbInterpreter.GetQuotedString($"{databaseObjectType.ToString().ToUpper()}_NAME"))
.Replace("$TABLE_NAME$", this.dbInterpreter.GetQuotedString($"TABLE_NAME"));
return(templateContent);
}
public DatabaseObject(DatabaseObjectType objectType, string fullyQualifiedName, int?id)
{
ObjectType = objectType;
FullyQualifiedName = fullyQualifiedName;
Properties = new List <ObjectProperty>();
Id = id;
ObjectState = ObjectState.Unchanged;
}
protected string CreateFilterExpression(DatabaseObjectType objectType, bool removeIdPrefix = true)
{
if (FilterOptions == null)
{
return(" is not null");
}
List <string> res = null;
if (objectType == DatabaseObjectType.Table && FilterOptions.TableFilter != null)
{
if (res == null)
{
res = new List <string>();
}
res.AddRange(FilterOptions.TableFilter);
}
if (objectType == DatabaseObjectType.View && FilterOptions.ViewFilter != null)
{
if (res == null)
{
res = new List <string>();
}
res.AddRange(FilterOptions.ViewFilter);
}
if (objectType == DatabaseObjectType.StoredProcedure && FilterOptions.StoredProcedureFilter != null)
{
if (res == null)
{
res = new List <string>();
}
res.AddRange(FilterOptions.StoredProcedureFilter);
}
if (objectType == DatabaseObjectType.Function && FilterOptions.FunctionFilter != null)
{
if (res == null)
{
res = new List <string>();
}
res.AddRange(FilterOptions.FunctionFilter);
}
if (objectType == DatabaseObjectType.Trigger && FilterOptions.TriggerFilter != null)
{
if (res == null)
{
res = new List <string>();
}
res.AddRange(FilterOptions.TriggerFilter);
}
if (res != null)
{
if (res.Count == 0)
{
return(" is null");
}
return(" in (" + res.Select(x => removeIdPrefix ? $"'{x.Substring(x.IndexOf(':') + 1)}'" : $"'{x}'").CreateDelimitedText(",") + ")");
}
return(" is not null");
}
public static DatabaseObjectType GetDbObjectTypeByFolderName(string folderName)
{
string value = ManagerUtil.GetSingularString(folderName);
DatabaseObjectType type = DatabaseObjectType.None;
Enum.TryParse(value, out type);
return(type);
}
private bool NeedTranslate(DatabaseObjectType databaseObjectType, DatabaseObjectType currentDbType)
{
if (databaseObjectType == DatabaseObjectType.None || databaseObjectType.HasFlag(currentDbType))
{
return(true);
}
return(false);
}
public IInitializedValidator AlsoCheck(DatabaseObjectType objectType, String schema, String name)
{
_additionalValidation.Add(new ValidationObject
{
ObjectType = objectType,
Schema = schema,
Name = name
});
return this;
}
private string CreateQuery(string resFileName, DatabaseObjectType objectType)
{
string res = PostgresDatabaseFactory.LoadEmbeddedResource(resFileName);
if (res.Contains("=[OBJECT_ID_CONDITION]"))
{
res = res.Replace(" =[OBJECT_ID_CONDITION]", CreateFilterExpression(objectType, false));
}
return(res);
}
public DatabaseObject(DatabaseObjectType type, byte[] content)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
Type = type;
Content = content;
}
/// <summary>
/// Returns the unique string key of a database object belonging to the dataset.
/// </summary>
/// <param name="objectType"></param>
/// <param name="datasetName"></param>
/// <param name="databaseName"></param>
/// <param name="schemaName"></param>
/// <param name="objectName"></param>
/// <returns></returns>
public override string GetObjectUniqueKey(DatabaseObjectType objectType, string datasetName, string databaseName, string schemaName, string objectName)
{
// If schema name is empty, use default schema name
schemaName =
String.IsNullOrWhiteSpace(schemaName) ?
DefaultSchemaName :
schemaName;
return(base.GetObjectUniqueKey(objectType, datasetName, databaseName, schemaName, objectName));
}
/// <summary>
/// When overriden in derived classes, returns a unique key of a
/// database object that can be used in web urls, etc.
/// </summary>
/// <param name="objectType"></param>
/// <param name="datasetName"></param>
/// <param name="databaseName"></param>
/// <param name="schemaName"></param>
/// <param name="objectName"></param>
/// <returns></returns>
public virtual string GetObjectUniqueKey(DatabaseObjectType objectType, string datasetName, string databaseName, string schemaName, string objectName)
{
return(String.Format(
"{0}|{1}|{2}|{3}|{4}",
objectType,
datasetName,
databaseName,
schemaName,
objectName));
}
private async void Fetch()
{
DatabaseType dbType;
if (this.useSourceConnector)
{
dbType = this.sourceDbProfile.DatabaseType;
if (!this.sourceDbProfile.IsDbTypeSelected())
{
MessageBox.Show("Please select a source database type.");
return;
}
if (!this.sourceDbProfile.IsProfileSelected())
{
MessageBox.Show("Please select a source database profile.");
return;
}
if (!this.sourceDbConnectionInfo.IntegratedSecurity && string.IsNullOrEmpty(this.sourceDbConnectionInfo.Password))
{
MessageBox.Show("Please specify password for the source database.");
this.sourceDbProfile.ConfigConnection(true);
return;
}
}
else
{
dbType = this.sourceDatabaseType;
}
this.btnFetch.Text = "...";
try
{
DatabaseObjectType excludeObjType = (this.sourceDatabaseType != DatabaseType.SqlServer || this.targetDbProfile.DatabaseType != DatabaseType.SqlServer) ? DatabaseObjectType.UserDefinedType : DatabaseObjectType.None;
await this.tvDbObjects.LoadTree(dbType, this.sourceDbConnectionInfo, excludeObjType);
this.btnExecute.Enabled = true;
}
catch (Exception ex)
{
this.tvDbObjects.ClearNodes();
string message = ExceptionHelper.GetExceptionDetails(ex);
LogHelper.LogError(message);
MessageBox.Show("Error:" + message);
}
this.btnFetch.Text = "Fetch";
}
private string CreateQuery(string resFileName, DatabaseObjectType objectType)
{
string res = MySqlDatabaseFactory.LoadEmbeddedResource(resFileName);
if (res.Contains("=[OBJECT_NAME_CONDITION]"))
{
res = res.Replace(" =[OBJECT_NAME_CONDITION]", CreateFilterExpression(objectType));
}
res = res.Replace("#DATABASE#", DatabaseName);
return(res);
}
/// <summary>
/// Copies member variable from an existing object
/// </summary>
/// <param name="old"></param>
private void CopyMembers(DatabaseObject old)
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = old.objectType;
this.dataset = old.dataset;
this.databaseName = old.databaseName;
this.schemaName = old.schemaName;
this.objectName = old.objectName;
this.metadata = new LazyProperty <DatabaseObjectMetadata>(LoadMetadata);
}
private void InitializeMembers(StreamingContext context)
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = DatabaseObjectType.Unknown;
this.dataset = null;
this.databaseName = null;
this.schemaName = null;
this.objectName = null;
this.metadata = new LazyProperty <DatabaseObjectMetadata>(LoadMetadata);
}
private DatabaseObject GetObjectCore(long objectOffset, Stream packFile, bool recursing)
{
long size = 0;
DatabaseObjectType type = DatabaseObjectType.Null;
using (BinaryReader rdr = new BinaryReader(packFile, Encoding.UTF8, leaveOpen: true))
{
packFile.Seek(objectOffset, SeekOrigin.Begin);
// ==01234567==
// | 1TTTSSSS |
// ============
// T = Type
// S = Size Start
var sizeAndType = rdr.ReadVarInteger(3);
type = InterpretType(sizeAndType.Item1);
size = sizeAndType.Item2;
long deltaOffset = -1;
if (type == DatabaseObjectType.OffsetDelta)
{
// This isn't _quite_ a var-integer as ReadVarInteger supports
byte read = rdr.ReadByte();
long offset = read & 0x7F;
while ((read & 0x80) == 0x80)
{
offset += 1;
offset <<= 7;
read = rdr.ReadByte();
offset += (read & 0x7F);
}
deltaOffset = objectOffset - offset;
}
else if (type == DatabaseObjectType.HashDelta)
{
byte[] hash = rdr.ReadBytes(20);
GitPackIndexEntry entry = Index.GetEntry(hash);
deltaOffset = entry.Offset;
}
byte[] data = Compression.WrapStreamForDecompression(packFile)
.ReadBytes(size);
if (deltaOffset >= 0)
{
DatabaseObject source = GetObjectCore(deltaOffset, packFile, recursing: true);
return(ConstructFromDelta(source, data));
}
else
{
return(new DatabaseObject(type, data));
}
}
}
private List <DbDifference> CompareDatabaseObjects <T>(string type, DatabaseObjectType databaseObjectType, IEnumerable <T> sourceObjects, IEnumerable <T> targetObjects)
where T : DatabaseObject
{
List <DbDifference> differences = new List <DbDifference>();
foreach (T target in targetObjects)
{
DbDifference difference = new DbDifference()
{
Type = type, DatabaseObjectType = databaseObjectType
};
T source = sourceObjects.FirstOrDefault(item => this.IsNameEquals(item.Name, target.Name));
if (source == null)
{
difference.DifferenceType = DbDifferenceType.Deleted;
difference.Target = target;
differences.Add(difference);
}
else
{
difference.Source = source;
difference.Target = target;
if (!this.IsDbObjectEquals(source, target))
{
difference.DifferenceType = DbDifferenceType.Modified;
}
differences.Add(difference);
}
}
foreach (T source in sourceObjects)
{
if (!targetObjects.Any(item => this.IsNameEquals(item.Name, source.Name)))
{
DbDifference difference = new DbDifference()
{
Type = type, DatabaseObjectType = databaseObjectType
};
difference.DifferenceType = DbDifferenceType.Added;
difference.Source = source;
differences.Add(difference);
}
}
return(differences);
}
private bool NeedFetchObjects(DatabaseObjectType currentObjectType, IEnumerable <string> names, SchemaInfoFilter filter)
{
bool hasName = names != null && names.Any();
if (filter.Strict)
{
return(hasName && filter.DatabaseObjectType.HasFlag(currentObjectType));
}
else
{
return(hasName || filter.DatabaseObjectType.HasFlag(currentObjectType));
}
}
internal IObjectMap MapObject <T>(DatabaseObjectType databaseObjectType) where T : class
{
var entityType = typeof(T);
if (!mappings.TryGetValue(entityType, out var map))
{
map = ObjectMap <T> .CreateMap(databaseObjectType, this.commandAdapter);
mappings[entityType] = map;
}
return(map);
}
public static string ToStandardString(DatabaseObjectType type)
{
switch (type)
{
case DatabaseObjectType.Commit: return "commit";
case DatabaseObjectType.Tree: return "tree";
case DatabaseObjectType.Blob: return "blob";
case DatabaseObjectType.Tag: return "tag";
case DatabaseObjectType.OffsetDelta: return "<<offset-delta>>";
case DatabaseObjectType.HashDelta: return "<<hash-delta>>";
case DatabaseObjectType.Null: return "<<null>>";
default: return "<<unknown>>";
}
}
/// <summary>
/// Creates a new ScripterBase base class of the type appropriate to
/// generate script for the SchemaCollection
/// </summary>
public static ScripterBase CreateScripter(ICollection objects, DatabaseObjectType objectType)
{
switch (objectType)
{
case DatabaseObjectType.Table:
return new TableScripter(objects);
case DatabaseObjectType.View:
return new ViewScripter(objects);
case DatabaseObjectType.StoredProcedure:
return new StoredProcedureScripter(objects);
case DatabaseObjectType.UserDefinedFunction:
return new UserDefinedFunctionScripter(objects);
case DatabaseObjectType.Schema:
return new SchemaScripter(objects);
default:
throw new ArgumentOutOfRangeException("objectType");
}
}
public List<string> this[DatabaseObjectType type]
{
get
{
switch (type)
{
case DatabaseObjectType.Table:
return TableFilter;
case DatabaseObjectType.View:
return ViewFilter;
case DatabaseObjectType.StoredProcedure:
return StoredProcedureFilter;
case DatabaseObjectType.Function:
return FunctionFilter;
case DatabaseObjectType.Trigger:
return TriggerFilter;
}
throw new Exception("DBSH-00139 Invalid database object type:" + type.ToString());
}
}
private void SetScriptParseOutput(
string name,
string content,
DatabaseObjectType objectType,
string schemaName = "dbo"
)
{
var script = new FakeSqlScript();
script.ObjectName = name;
script.ObjectType = objectType;
script.SchemaName = schemaName;
script.OriginalText = content;
_parser.ParseScriptOutput[content] = script;
}
/// <summary>
/// �õ����ݿ���������б�
/// </summary>
/// <param name="ConnString">�����ַ���</param>
/// <param name="DBOType">��������</param>
/// <returns></returns>
private List<string> GetDatabaseObjectList(string connectionString, DatabaseObjectType DBOType)
{
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
string strCmd, strSType = "";
List<string> retList = new List<string>();
switch (DBOType)
{
case DatabaseObjectType.Table:
strSType = "U";
break;
case DatabaseObjectType.View:
strSType = "V";
break;
case DatabaseObjectType.StoreProcedure:
strSType = "P";
break;
}
strCmd = string.Format("select [name] from sysobjects where xtype = '{0}' and status >= 0 order by [name]", strSType);
DataSet ds = new DataSet("OList");
SqlHelper.FillDataset(connectionString, CommandType.Text, strCmd, ds, new string[] { "List" });
foreach (DataRow var in ds.Tables["List"].Rows)
{
retList.Add(var["name"].ToString());
}
return retList;
}
/// <summary>
/// Creates an instance of a mismatched object type error object.
/// </summary>
/// <param name="objectName">The name of the build item.</param>
/// <param name="expected">The type of object to which the directory belongs.</param>
/// <param name="actual">The type of object in the script content.</param>
public MismatchedObjectTypeError(string objectName, DatabaseObjectType expected, DatabaseObjectType actual)
{
ActualType = actual;
ExpectedType = expected;
ObjectName = objectName;
}
public TableDifference(bool isLeftDifferent, string name, DatabaseObjectType objectType, DifferenceOutcome outcome)
: base(isLeftDifferent, name, objectType, outcome)
{
}
/// <summary>
/// Copies member variable from an existing object
/// </summary>
/// <param name="old"></param>
private void CopyMembers(DatabaseObject old)
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = old.objectType;
this.dataset = old.dataset;
this.databaseName = old.databaseName;
this.schemaName = old.schemaName;
this.objectName = old.objectName;
}
public DatabaseObject(DatabaseObjectType objectType)
{
this.ObjectType = objectType;
}
/// <summary>
/// Initializes member variable to their default values
/// </summary>
private void InitializeMembers()
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = DatabaseObjectType.Unknown;
this.dataset = null;
this.databaseName = null;
this.schemaName = null;
this.objectName = null;
}
private void InitializeMembers(StreamingContext context)
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = DatabaseObjectType.Unknown;
this.dataset = null;
this.databaseName = null;
this.schemaName = null;
this.objectName = null;
this.metadata = new LazyProperty<DatabaseObjectMetadata>(LoadMetadata);
}
/// <summary>
/// Copies member variable from an existing object
/// </summary>
/// <param name="old"></param>
private void CopyMembers(DatabaseObject old)
{
this.cachedVersion = DateTime.Now.Ticks;
this.objectType = old.objectType;
this.dataset = old.dataset;
this.databaseName = old.databaseName;
this.schemaName = old.schemaName;
this.objectName = old.objectName;
this.metadata = new LazyProperty<DatabaseObjectMetadata>(LoadMetadata);
}
/// <summary>
/// Instantiates a database object with the given identifiers.
/// </summary>
/// <param name="serverName">The name of the database server.</param>
/// <param name="databaseName">The name of the database.</param>
/// <param name="schemaName">The name of the schema.</param>
/// <param name="objectName">The name of the object.</param>
/// <param name="objectType">The type of the object.</param>
public TypedDatabaseObject(string serverName, string databaseName, string schemaName, string objectName, DatabaseObjectType objectType)
: base(serverName, databaseName, schemaName, objectName)
{
ObjectType = objectType;
}
private void FillOutDatabaseObjectNames(string cmdName, CheckedListBox clb, DatabaseObjectType objectType)
{
string objectName;
string strCmd = ConfigurationManager.AppSettings[cmdName];
Database db = DatabaseFactory.CreateDatabase();
Action beginUpdate = () => clb.BeginUpdate();
clb.Invoke(beginUpdate);
using (IDataReader reader = db.ExecuteReader(CommandType.Text, strCmd))
{
Action addItem;
while (reader.Read())
{
objectName = reader.GetString(0);
addItem = () => clb.Items.Add(new ListItem() { Value = objectName, Type = objectType });
clb.Invoke(addItem);
}
}
Action endUpdate = () => clb.EndUpdate();
clb.Invoke(endUpdate);
}
public ObjectOperationCaps GetSpecificObjectCaps(DatabaseObjectType objectType)
{
return new ObjectOperationCaps {AllFlags = true};
}
