/// <summary> /// Enumerates items for a set of data objects of the specified type /// with the specified restrictions and sort string, if supported. /// </summary> /// <param name="typeName">Name of the type of the object to enumerate.</param> /// <param name="items"> /// The set of items to enumerate, specified as strings where named items are available, /// otherwise as indexes. In cases in which a data provider does not support items /// filtering, this parameter is ignored. /// NOT SUPPORTED. /// </param> /// <param name="restrictions"> /// A set of filtering restrictions to apply to the set of returned objects. /// </param> /// <param name="sort"> /// A sort string, which follows syntax for the SQL Server ORDER BY clause. /// The actual sort order should be source-based; that is, if the client is /// English and the source is Chinese, the sort should be applied in Chinese. /// NOT SUPPORTED. /// </param> /// <param name="parameters"> /// An array whose contents are defined by the given implementation of /// EnumerateObjects, and which is specified by the Data Object Support /// XML file. Information supplied in this parameter can be used to provide /// extra data indicating how to perform the enumeration, allowing /// implementations of this method to be more data driven. /// NOT USED. /// </param> /// <returns> /// Returns a DataReader object containing the results of the enumeration call. /// </returns> public override DataReader EnumerateObjects( string typeName, object[] items, object[] restrictions, string sort, object[] parameters) { if (typeName == null) { throw new ArgumentNullException("typeName"); } // Chose restricitions array object[] appliedRestrictions; if (typeName.Equals(RootDescriptor.TypeName, StringComparison.InvariantCultureIgnoreCase)) { appliedRestrictions = new object[] { ConnectionWrapper.ServerName, ConnectionWrapper.Schema }; } else { appliedRestrictions = restrictions; } DataTable table; try { // Enumerate objects into table table = ObjectDescriptor.EnumerateObjects(ConnectionWrapper, typeName, appliedRestrictions, sort); } catch (DbException e) { SqlErrorDialog.ShowError(e, ConnectionWrapper.GetFullStatus()); throw; } catch (Exception e) { UIHelper.ShowError(e); throw; } // Validate table if (table == null) { Debug.Fail("Failed to enumerate objects of type '" + typeName + "'!"); return(null); } // Enumerete objects in to DataReader return(new AdoDotNetDataTableReader(table)); }
/// <summary> /// Drops single item. Uses object descriptor to build DROP statement. /// </summary> /// <param name="hierarchy">Server explorer facade object to be used for Server Explorer hierarchy interaction.</param> /// <param name="item">Item identifier.</param> /// <returns>Result of execution. Typicaly null.</returns> protected override object ExecuteSingleItem(ServerExplorerFacade hierarchy, int item) { if (hierarchy == null) { throw new ArgumentNullException("hierarchy"); } if (item < 0) { throw new ArgumentOutOfRangeException("item"); } // Extract type name string typeName = GetObjectType(hierarchy, item); if (String.IsNullOrEmpty(typeName)) { Debug.Fail("Failed to get object type!"); return(false); } // Extract descriptor IObjectDescriptor descriptor = ObjectDescriptorFactory.Instance.CreateDescriptor(typeName); if (descriptor == null || !descriptor.CanBeDropped) { Debug.Fail("Failed to get descriptor or descriptor doesn't support dropping!"); return(null); } // Extract object identifier object[] identifier = hierarchy.GetObjectIdentifier(item); if (identifier == null) { Debug.Fail("Failed to get object identifier!"); return(null); } // TODO: Note the seconde check for TableData document. It should be replaced in the future // by the generic mechanism. // Check if editor is registered for the database object if (hierarchy.HasDocument(typeName, identifier) || hierarchy.HasDocument(TableDataDescriptor.TypeName, identifier)) { UIHelper.ShowError(String.Format( CultureInfo.InvariantCulture, Resources.Error_CantDropBecauseOfEditor, hierarchy.GetName(item))); return(null); } // Build DROP query string dropQuery = String.Empty; if (descriptor is StoredProcDescriptor) { dropQuery = (descriptor as StoredProcDescriptor).BuildDropSql( hierarchy, item, identifier); } else { dropQuery = descriptor.BuildDropSql(identifier); } if (String.IsNullOrEmpty(dropQuery)) { Debug.Fail("Failed to build DROP query!"); return(null); } // Extract connection DataConnectionWrapper connection = hierarchy.Connection; if (connection == null) { Debug.Fail("Failed to extract connection!"); return(null); } try { // Execute drop query connection.ExecuteScalar(dropQuery); // Drop hierarchy node hierarchy.DropObjectNode(item); // Notify everybody about object dropping connection.ObjectChangeEvents.RaiseObjectRemoved(typeName, identifier); } catch (DbException e) { Trace.TraceError("Error during saving object:\n{0}", e.ToString()); SqlErrorDialog.ShowError(e, connection.GetFullStatus()); } catch (Exception e) { Trace.TraceError("Error during saving object:\n{0}", e.ToString()); UIHelper.ShowError(e); } return(null); }