/// <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}; }