public void Init() { _view.InitializeGrid(); _view.UseTransactionEnabled = (_conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsTransactions)); using (FdoFeatureService service = _conn.CreateFeatureService()) { ClassDefinition cd = service.GetClassByName(_className); if (cd != null) { _view.ClassName = cd.Name; foreach (PropertyDefinition pd in cd.Properties) { switch (pd.PropertyType) { case PropertyType.PropertyType_DataProperty: _view.AddDataProperty((DataPropertyDefinition)pd); break; case PropertyType.PropertyType_GeometricProperty: _view.AddGeometricProperty((GeometricPropertyDefinition)pd); break; } } } } }
private void GetDataStores() { using (FdoFeatureService service = _conn.CreateFeatureService()) { ReadOnlyCollection <DataStoreInfo> dstores = service.ListDataStores(true); _view.DataStores = dstores; _view.DestroyEnabled = (dstores.Count > 0) && canDestroy; } }
public void ComputeExtents(IEnumerable <ClassDefinition> classes) { using (FdoFeatureService service = _conn.CreateFeatureService()) { IEnvelope env = service.ComputeEnvelope(classes); if (env != null) { _view.LowerLeftX = env.MinX.ToString(); _view.LowerLeftY = env.MinY.ToString(); _view.UpperRightX = env.MaxX.ToString(); _view.UpperRightY = env.MaxY.ToString(); } } }
protected override void OnLoad(EventArgs e) { cmbJoinType.DataSource = _conn.Capability.GetArrayCapability(CapabilityType.FdoCapabilityType_JoinTypes); using (var svc = _conn.CreateFeatureService()) { cmbSchema.DataSource = svc.DescribeSchema(); cmbSchema.SelectedIndex = 0; } if (this.Criteria != null) { foreach (FeatureSchema fs in (FeatureSchemaCollection)cmbSchema.DataSource) { if (fs.Name == this.Criteria.JoinSchema) { cmbSchema.SelectedIndex = cmbSchema.Items.IndexOf(fs); foreach (ClassDefinition cls in fs.Classes) { if (cls.Name == this.Criteria.JoinClass) { cmbClass.SelectedIndex = cmbClass.Items.IndexOf(cls); txtJoinClassAlias.Text = this.Criteria.JoinClassAlias; txtJoinFilter.Text = this.Criteria.JoinFilter; txtPrefix.Text = this.Criteria.JoinPrefix; cmbJoinType.SelectedItem = this.Criteria.JoinType; } } } } } }
internal void SchemaChanged(JoinSourceType type) { if (type == JoinSourceType.Target) { return; } _view.ClearJoins(); FdoConnection conn = GetConnection(type); if (conn != null) { using (FdoFeatureService service = conn.CreateFeatureService()) { switch (type) { case JoinSourceType.Left: _view.LeftClasses = service.GetClassNames(_view.SelectedLeftSchema); ClassChanged(type); break; case JoinSourceType.Right: _view.RightClasses = service.GetClassNames(_view.SelectedRightSchema); ClassChanged(type); break; } } } }
/// <summary> /// Gets all class names from the specified flat-file data source /// </summary> /// <param name="sourceFile"></param> /// <returns></returns> public static string[] GetClassNames(string sourceFile) { List <string> classnames = new List <string>(); FdoConnection source = null; try { source = CreateFlatFileConnection(sourceFile); source.Open(); using (FdoFeatureService svc = source.CreateFeatureService()) { using (FeatureSchemaCollection schemas = svc.DescribeSchema()) { foreach (FeatureSchema sch in schemas) { foreach (ClassDefinition cd in sch.Classes) { classnames.Add(cd.Name); } } } } } catch (Exception ex) { } finally { if (source != null) { source.Dispose(); } } return(classnames.ToArray()); }
/// <summary> /// Copies all spatial contexts /// </summary> /// <param name="spatialContexts">The spatial contexts.</param> /// <param name="target">The target.</param> /// <param name="overwrite">if set to <c>true</c> [overwrite].</param> public override void Execute(ICollection <SpatialContextInfo> spatialContexts, FdoConnection target, bool overwrite) { //MySQL supports multiple spatial contexts and IDestorySpatialContext //so in this case if overwrite == true, we want to destroy any ones that //already exist in the target before creating new ones in its place. This does not //prevent creating a series of spatial contexts if overwrite == false and one of //the spatial contexts being copied already exists. This is an unfortunate leaky //abstraction in the FDO API. using (FdoFeatureService service = target.CreateFeatureService()) { if (overwrite) { ReadOnlyCollection <SpatialContextInfo> targetContexts = service.GetSpatialContexts(); foreach (SpatialContextInfo sc in spatialContexts) { //Only destroy spatial context if it exists in target connection if (SpatialContextExists(targetContexts, sc)) { service.DestroySpatialContext(sc); } } } foreach (SpatialContextInfo sc in spatialContexts) { service.CreateSpatialContext(sc, false); } } }
public override void ExecuteAction() { using (FdoFeatureService svc = _conn.CreateFeatureService()) { using (IDelete del = svc.CreateCommand <IDelete>(OSGeo.FDO.Commands.CommandType.CommandType_Delete)) { try { del.SetFeatureClassName(_className); if (!string.IsNullOrEmpty(_filter)) { del.SetFilter(_filter); Info("Deleting everything from class " + _className + " with filter: " + _filter); } else { Info("Deleting everything from class: " + _className); } int result = del.Execute(); Info(result + " features deleted from class: " + _className); } catch (OSGeo.FDO.Common.Exception ex) { Error(ex, "Error occured executing delete"); } } } }
/// <summary> /// Initializes this instance. /// </summary> protected override void Initialize() { SendMessage("Creating target data source"); if (!ExpressUtility.CreateFlatFileDataSource(_outputFile)) { throw new FdoETLException(ResourceUtil.GetStringFormatted("ERR_CANNOT_CREATE_DATA_FILE", _outputFile)); } _outConn = ExpressUtility.CreateFlatFileConnection(_outputFile); _outConn.Open(); ClassDefinition cd = _table.CreateClassDefinition(true); using (FdoFeatureService service = _outConn.CreateFeatureService()) { SendMessage("Applying schema to target"); FeatureSchema schema = new FeatureSchema("Schema1", "Default schema"); schema.Classes.Add(cd); service.ApplySchema(schema); } SendMessage("Copying any attached spatial contexts"); ExpressUtility.CopyAllSpatialContexts(_table.SpatialContexts, _outConn, true); Register(new FdoFeatureTableInputOperation(_table)); Register(new FdoOutputOperation(_outConn, cd.Name)); }
public SchemaDesignContext(FdoConnection conn) { _spatialContexts = new BindingList <SpatialContextInfo>(); if (conn == null) { _schemas = new FeatureSchemaCollection(null); _mappings = new PhysicalSchemaMappingCollection(); } else { using (var svc = conn.CreateFeatureService()) { _schemas = svc.DescribeSchema(); _mappings = svc.DescribeSchemaMapping(true); if (_mappings == null) { _mappings = new PhysicalSchemaMappingCollection(); } var spatialContexts = svc.GetSpatialContexts(); foreach (var sc in spatialContexts) { _spatialContexts.Add(sc); } } } this.Connection = conn; EvaluateCapabilities(); }
internal void ConnectionChanged(JoinSourceType type) { if (type != JoinSourceType.Target) { _view.ClearJoins(); } FdoConnection conn = GetConnection(type); if (conn != null) { using (FdoFeatureService service = conn.CreateFeatureService()) { switch (type) { case JoinSourceType.Left: _view.LeftSchemas = service.GetSchemaNames(); SchemaChanged(type); break; case JoinSourceType.Right: _view.RightSchemas = service.GetSchemaNames(); SchemaChanged(type); break; case JoinSourceType.Target: _view.TargetSchemas = service.GetSchemaNames(); SchemaChanged(type); break; } } } }
/// <summary> /// Validates this instance. /// </summary> public void Validate() { foreach (FdoClassCopyOptions copt in this.ClassCopyOptions) { FdoConnection src = GetConnection(copt.SourceConnectionName); FdoConnection dst = GetConnection(copt.TargetConnectionName); if (src == null) { throw new TaskValidationException("The specified source connection name does not exist"); } if (dst == null) { throw new TaskValidationException("The specified target connection name does not exist"); } using (FdoFeatureService srcSvc = src.CreateFeatureService()) using (FdoFeatureService dstSvc = dst.CreateFeatureService()) { ClassDefinition srcCls = srcSvc.GetClassByName(copt.SourceSchema, copt.SourceClassName); ClassDefinition dstCls = dstSvc.GetClassByName(copt.TargetSchema, copt.TargetClassName); if (srcCls == null) { throw new TaskValidationException("The specified source feature class does not exist"); } if (dstCls == null) { throw new TaskValidationException("The specified target feature class does not exist"); } } } }
public override void Run() { string path = FileService.SaveFile(Res.GetString("TITLE_EXPORT_DATASTORE_XML"), Res.GetString("FILTER_XML_FILES")); if (!string.IsNullOrEmpty(path)) { TreeNode connNode = Workbench.Instance.ObjectExplorer.GetSelectedNode(); FdoConnectionManager mgr = ServiceManager.Instance.GetService <FdoConnectionManager>(); FdoConnection conn = mgr.GetConnection(connNode.Name); using (new TempCursor(Cursors.WaitCursor)) { using (var svc = conn.CreateFeatureService()) { var scs = new List <SpatialContextInfo>(svc.GetSpatialContexts()).ToArray(); var schemas = svc.DescribeSchema(); var mappings = svc.DescribeSchemaMapping(true); var dstore = new FdoDataStoreConfiguration(schemas, scs, mappings); dstore.Save(path); Log.InfoFormatted("Connection saved to: {0}", path); } } } }
public void CopySpatialContexts() { List <SpatialContextInfo> contexts = new List <SpatialContextInfo>(); FdoConnection srcConn = _connMgr.GetConnection(_view.SourceConnectionName); FdoConnection targetConn = _connMgr.GetConnection(_view.SelectedTargetConnectionName); using (FdoFeatureService service = srcConn.CreateFeatureService()) { foreach (string ctxName in _view.SpatialContexts) { SpatialContextInfo sc = service.GetSpatialContext(ctxName); if (sc != null) { contexts.Add(sc); } } } if (contexts.Count == 0) { _view.ShowMessage(null, ResourceService.GetString("MSG_NO_SPATIAL_CONTEXTS_COPIED")); return; } ExpressUtility.CopyAllSpatialContexts(contexts, targetConn, _view.Overwrite); _view.ShowMessage(null, ResourceService.GetString("MSG_SPATIAL_CONTEXTS_COPIED")); _view.Close(); }
public bool CreateSqlite() { if (_view.CreateConnection && string.IsNullOrEmpty(_view.ConnectionName)) { _view.ShowError("Specify a connection name"); return(false); } if (ExpressUtility.CreateFlatFileDataSource("OSGeo.SQLite", _view.SQLiteFile)) { FdoConnection conn = ExpressUtility.CreateFlatFileConnection("OSGeo.SQLite", _view.SQLiteFile); if (FileService.FileExists(_view.FeatureSchemaDefinition)) { conn.Open(); using (FdoFeatureService service = conn.CreateFeatureService()) { service.LoadSchemasFromXml(_view.FeatureSchemaDefinition, _view.FixIncompatibilities); } } if (_view.CreateConnection) { _connMgr.AddConnection(_view.ConnectionName, conn); } else { conn.Dispose(); } } return(true); }
public override int Execute() { CommandStatus retCode = CommandStatus.E_OK; bool create = ExpressUtility.CreateFlatFileDataSource(_file); if (!create) { WriteLine("Failed to create file {0}", _file); retCode = CommandStatus.E_FAIL_CREATE_DATASTORE; return((int)retCode); } WriteLine("File {0} created", _file); if (_schema != null) { try { FdoConnection conn = ExpressUtility.CreateFlatFileConnection(_file); conn.Open(); using (FdoFeatureService service = conn.CreateFeatureService()) { service.LoadSchemasFromXml(_schema); WriteLine("Schema applied to {0}", _file); } retCode = CommandStatus.E_OK; } catch (Exception ex) { WriteException(ex); retCode = CommandStatus.E_FAIL_APPLY_SCHEMA; } } return((int)retCode); }
public FdoDataPreviewPresenter(IFdoDataPreviewView view, FdoConnection conn) { _timer = new Timer(); _view = view; _connection = conn; _service = conn.CreateFeatureService(); _queryViews = new Dictionary <QueryMode, IQuerySubView>(); _queryWorker = new BackgroundWorker(); _queryWorker.WorkerReportsProgress = true; _queryWorker.WorkerSupportsCancellation = true; _queryWorker.DoWork += new DoWorkEventHandler(DoWork); //_queryWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged); _queryWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted); _view.ElapsedMessage = string.Empty; _view.CancelEnabled = false; _view.ExecuteEnabled = true; insertSupported = (Array.IndexOf(conn.Capability.GetArrayCapability(CapabilityType.FdoCapabilityType_CommandList), OSGeo.FDO.Commands.CommandType.CommandType_Insert) >= 0); updateSupported = (Array.IndexOf(conn.Capability.GetArrayCapability(CapabilityType.FdoCapabilityType_CommandList), OSGeo.FDO.Commands.CommandType.CommandType_Update) >= 0); deleteSupported = (Array.IndexOf(conn.Capability.GetArrayCapability(CapabilityType.FdoCapabilityType_CommandList), OSGeo.FDO.Commands.CommandType.CommandType_Delete) >= 0); _view.DeleteEnabled = deleteSupported; _view.UpdateEnabled = updateSupported; _timer.Interval = 1000; _timer.Elapsed += new ElapsedEventHandler(OnTimerElapsed); }
private static void SetConnectionToolTip(TreeNode connNode, FdoConnection conn) { using (FdoFeatureService service = conn.CreateFeatureService()) { List <string> ctxStrings = new List <string>(); try { ICollection <SpatialContextInfo> contexts = service.GetSpatialContexts(); foreach (SpatialContextInfo sci in contexts) { if (sci.IsActive) { ctxStrings.Add("- " + sci.Name + " (Active)"); } else { ctxStrings.Add("- " + sci.Name); } } } catch { ctxStrings.Add("Could not retrieve spatial contexts"); } string configStatus = conn.HasConfiguration ? "(This connection has custom configuration applied)" : string.Empty; connNode.ToolTipText = string.Format( "Provider: {0}{4}Type: {1}{4}Connection String: {2}{4}Spatial Contexts:{4}{3}{4}{5}", conn.Provider, conn.DataStoreType, conn.SafeConnectionString, ctxStrings.Count > 0 ? string.Join("\n", ctxStrings.ToArray()) : "none", Environment.NewLine, configStatus); } }
public FdoSpatialContextBrowserDlg(FdoConnection conn) : this() { using (FdoFeatureService service = conn.CreateFeatureService()) { grdSpatialContexts.DataSource = service.GetSpatialContexts(); } }
public FdoAggregateQueryPresenter(IFdoAggregateQueryView view, FdoConnection conn) { _view = view; _conn = conn; _service = _conn.CreateFeatureService(); _view.OrderingEnabled = false; _walker = SchemaWalker.GetWalker(conn); }
public FdoStandardQueryPresenter(IFdoStandardQueryView view, FdoConnection conn) { _view = view; _conn = conn; _service = _conn.CreateFeatureService(); _view.OrderingEnabled = conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsSelectOrdering); _walker = SchemaWalker.GetWalker(conn); }
internal void ClassChanged(JoinSourceType type) { if (type == JoinSourceType.Target) { return; } _view.ClearJoins(); FdoConnection conn = GetConnection(type); if (conn != null) { using (FdoFeatureService service = conn.CreateFeatureService()) { switch (type) { case JoinSourceType.Left: { string schema = _view.SelectedLeftSchema; string className = _view.SelectedLeftClass; ClassDefinition cd = service.GetClassByName(schema, className); if (cd != null) { List <string> properties = new List <string>(); foreach (PropertyDefinition pd in cd.Properties) { properties.Add(pd.Name); } _view.LeftProperties = properties; } } break; case JoinSourceType.Right: { string schema = _view.SelectedRightSchema; string className = _view.SelectedRightClass; ClassDefinition cd = service.GetClassByName(schema, className); if (cd != null) { List <string> properties = new List <string>(); foreach (PropertyDefinition pd in cd.Properties) { properties.Add(pd.Name); } _view.RightProperties = properties; } } break; } } } SetTargetGeometries(); }
internal void Delete() { if (_view.Confirm("Bulk Delete", "Bulk deletes can be very lengthy. Are you sure you want to do this?")) { using (FdoFeatureService service = _conn.CreateFeatureService()) { int deleted = service.DeleteFeatures(_className, _view.Filter.Trim(), _view.UseTransaction); _view.ShowMessage(null, deleted + " feature(s) deleted"); } if (_conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsFlush)) { _conn.Flush(); } _view.Close(); } }
/// <summary> /// Executes the operation /// </summary> /// <param name="rows"></param> /// <returns></returns> public override IEnumerable <FdoRow> Execute(IEnumerable <FdoRow> rows) { using (FdoFeatureService service = _conn.CreateFeatureService()) { using (FdoFeatureReader reader = service.SelectFeatures(this.Query)) { ClassDefinition cd = reader.GetClassDefinition(); foreach (PropertyDefinition pd in cd.Properties) { if (pd.PropertyType == PropertyType.PropertyType_RasterProperty) { ignoreProperties.Add(pd.Name); } else if (pd.PropertyType == PropertyType.PropertyType_DataProperty) { DataPropertyDefinition dp = pd as DataPropertyDefinition; if (dp.IsAutoGenerated || dp.ReadOnly) { ignoreProperties.Add(pd.Name); } } else if (pd.PropertyType == PropertyType.PropertyType_GeometricProperty) { GeometricPropertyDefinition gp = pd as GeometricPropertyDefinition; if (gp.ReadOnly) { ignoreProperties.Add(gp.Name); } } } while (reader.ReadNext()) { FdoRow row = null; try { row = CreateRowFromReader(reader); } catch (Exception ex) { if (row != null) { RaiseFailedFeatureProcessed(row, ex); } else { RaiseFailedReadFeature(ex.Message, ex); } } if (row != null) { yield return(row); } } } } }
/// <summary> /// Copies the spatial contexts given in the list /// </summary> /// <param name="source">The source connection</param> /// <param name="target">The target connection</param> /// <param name="overwrite">If true will overwrite any existing spatial contexts</param> /// <param name="spatialContextNames">The list of spatial contexts to copy</param> public virtual void Execute(FdoConnection source, FdoConnection target, bool overwrite, string[] spatialContextNames) { if (spatialContextNames.Length == 0) { return; } using (FdoFeatureService sService = source.CreateFeatureService()) using (FdoFeatureService tService = target.CreateFeatureService()) { bool supportsMultipleScs = target.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsMultipleSpatialContexts); bool supportsDestroySc = target.Capability.HasArrayCapability(CapabilityType.FdoCapabilityType_CommandList, (int)OSGeo.FDO.Commands.CommandType.CommandType_DestroySpatialContext); if (supportsMultipleScs) { //Get all contexts in target ReadOnlyCollection <SpatialContextInfo> contexts = tService.GetSpatialContexts(); List <string> updated = new List <string>(); //Destroy any clashing ones if (overwrite && supportsDestroySc) { foreach (SpatialContextInfo c in contexts) { if (SpatialContextInSpecifiedList(c, spatialContextNames)) { tService.DestroySpatialContext(c); } } } //Then overwrite them foreach (SpatialContextInfo c in contexts) { if (SpatialContextInSpecifiedList(c, spatialContextNames)) { tService.CreateSpatialContext(c, overwrite); updated.Add(c.Name); } } //Now create the rest var sourceScs = sService.GetSpatialContexts(); foreach (var sc in sourceScs) { if (!updated.Contains(sc.Name)) { tService.CreateSpatialContext(sc, overwrite); } } } else { tService.CreateSpatialContext(sService.GetActiveSpatialContext(), true); } } }
private void bgExecutor_DoWork(object sender, DoWorkEventArgs e) { string sql = e.Argument.ToString(); using (var svc = _conn.CreateFeatureService()) { int affected = svc.ExecuteSQLNonQuery(sql); e.Result = affected; } }
/// <summary> /// Copies all spatial contexts /// </summary> /// <param name="spatialContexts">The spatial contexts.</param> /// <param name="target">The target.</param> /// <param name="overwrite">if set to <c>true</c> [overwrite].</param> public virtual void Execute(ICollection <SpatialContextInfo> spatialContexts, FdoConnection target, bool overwrite) { bool supportsMultipleScs = target.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsMultipleSpatialContexts); bool supportsDestroySc = target.Capability.HasArrayCapability(CapabilityType.FdoCapabilityType_CommandList, (int)OSGeo.FDO.Commands.CommandType.CommandType_DestroySpatialContext); using (FdoFeatureService service = target.CreateFeatureService()) { if (supportsMultipleScs) { if (overwrite && supportsDestroySc) { ReadOnlyCollection <SpatialContextInfo> targetContexts = service.GetSpatialContexts(); foreach (SpatialContextInfo sc in spatialContexts) { //Only destroy spatial context if it exists in target connection if (SpatialContextExists(targetContexts, sc)) { service.DestroySpatialContext(sc); } } } foreach (SpatialContextInfo sc in spatialContexts) { service.CreateSpatialContext(sc, overwrite); } } else { List <SpatialContextInfo> contexts = new List <SpatialContextInfo>(spatialContexts); //Copy either the active spatial context in the list or the first //spatial context (if no active one is found) SpatialContextInfo active = null; if (contexts.Count > 0) { foreach (SpatialContextInfo sc in contexts) { if (sc.IsActive) { active = sc; break; } } if (active == null) { active = contexts[0]; } } if (active != null) { service.CreateSpatialContext(active, overwrite); } } } }
void CreateSchemaNodes(TreeNode connNode) { Action <TimeSpan> act = (ts) => LoggingService.Info("Connection " + connNode.Name + ": Schema population completed in " + ts.TotalMilliseconds + "ms"); FdoConnection conn = _connMgr.GetConnection(connNode.Name); if (conn != null) { using (FdoFeatureService service = conn.CreateFeatureService()) { if (service.SupportsPartialSchemaDiscovery()) { using (var measure = new TimeMeasurement(act)) { List <string> schemaNames = service.GetSchemaNames(); //Pre-sort SortedList <string, string> sorted = new SortedList <string, string>(); foreach (string name in schemaNames) { sorted.Add(name, name); } foreach (string name in schemaNames) { TreeNode schemaNode = CreateSchemaNode(name, true); connNode.Nodes.Add(schemaNode); schemaNode.Nodes.Add(ResourceService.GetString("TEXT_LOADING")); } } } else { using (var measure = new TimeMeasurement(act)) { FeatureSchemaCollection schemas = service.DescribeSchema(); //Pre-sort SortedList <string, FeatureSchema> sorted = new SortedList <string, FeatureSchema>(); foreach (FeatureSchema schema in schemas) { sorted.Add(schema.Name, schema); } foreach (FeatureSchema schema in schemas) { TreeNode schemaNode = CreateSchemaNode(schema.Name, false); GetClassNodesFull(schema, schemaNode); connNode.Nodes.Add(schemaNode); schemaNode.Expand(); } } } } } }
public FdoStandardQueryPresenter(IFdoStandardQueryView view, FdoConnection conn) { _view = view; _conn = conn; _service = _conn.CreateFeatureService(); _view.UseExtendedSelectForOrdering = false; bool bExtended = Array.IndexOf(conn.Capability.GetArrayCapability(CapabilityType.FdoCapabilityType_CommandList), CommandType.CommandType_ExtendedSelect) >= 0; _view.OrderingEnabled = conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsSelectOrdering) || bExtended; _view.UseExtendedSelectForOrdering = bExtended; _walker = SchemaWalker.GetWalker(conn); }
/// <summary> /// Executes the operation /// </summary> /// <param name="rows"></param> /// <returns></returns> public override IEnumerable <FdoRow> Execute(IEnumerable <FdoRow> rows) { //We fetch the class def here instead of the ctor as the class in question //may have to be created by a pre-copy operation _clsDef = _service.GetClassByName(this.ClassName); IInsert insert = null; using (FdoFeatureService service = _conn.CreateFeatureService()) { insert = service.CreateCommand <IInsert>(CommandType.CommandType_Insert); } this.Info("Set feature class to: {0}", this.ClassName); insert.SetFeatureClassName(this.ClassName); PropertyValueCollection propVals = insert.PropertyValues; Prepare(propVals); foreach (FdoRow row in rows) { Bind(row); insert.Prepare(); try { using (IFeatureReader reader = insert.Execute()) { reader.Close(); } } catch (OSGeo.FDO.Common.Exception ex) { ex.Data["Class/Table"] = this.ClassName; RaiseFailedFeatureProcessed(row, ex); RePrepare(propVals); } yield return(row); } insert.Dispose(); //yield break; }