public void BeginExecuteQueryBlockUntilDone()
{
MockRepository mocks = new MockRepository();
IFeatureProvider adapted = mocks.CreateMock <IFeatureProvider>();
IExtents iExtentsStub =
MockRepository.GenerateStub <IExtents>();
FeatureQueryExpression featureQueryExpressionStub =
MockRepository.GenerateStub <FeatureQueryExpression>(iExtentsStub, SpatialOperation.Intersects);
_returnReaderStub = MockRepository.GenerateStub <IFeatureDataReader>();
_sleepInterval = 750;
using (mocks.Unordered())
{
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub))
.Do(new ExecuteQueryDelegate(executeQueryMock));
}
mocks.ReplayAll();
AsyncFeatureProviderAdapter adapter = new AsyncFeatureProviderAdapter(adapted);
IAsyncResult ar = adapter.BeginExecuteQuery(featureQueryExpressionStub, null);
Assert.NotNull(ar);
Stopwatch timer = Stopwatch.StartNew();
Assert.Same(_returnReaderStub, adapter.EndExecuteQuery(ar));
timer.Stop();
Assert.True(ar.IsCompleted);
Assert.False(ar.CompletedSynchronously);
Assert.True(timer.ElapsedMilliseconds > 500L);
mocks.VerifyAll();
}
public void MovingRowTriggersViewListChangedItemMovedNotification()
{
// TODO: implement MovingRowTriggersViewListChangedItemMovedNotification
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemMoved)
{
addNotificationOccured = true;
}
};
Assert.True(addNotificationOccured);
}
public void AddingRowToTableTriggersViewListChangedItemAddedNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(halfBounds);
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemAdded)
{
addNotificationOccured = true;
}
};
FeatureDataRow row = table.NewRow();
row["Oid"] = Guid.NewGuid();
row["FeatureName"] = "New row";
row.Geometry = _factories.GeoFactory.CreatePoint2D(44, 44);
table.AddRow(row);
Assert.True(addNotificationOccured);
}
public void ChangeViewSpatialFilterReturnsOnlyFilteredRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader);
IGeometry queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
List <FeatureDataRow> expectedRows = new List <FeatureDataRow>();
foreach (FeatureDataRow row in table)
{
IGeometry g = row.Geometry;
if (queryExtents.Intersects(g))
{
expectedRows.Add(row);
}
}
FeatureDataView view = new FeatureDataView(table);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.Equal(expectedRows.Count, view.Count);
}
public void ChangeViewSpatialFilterTriggersNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
IExtents queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.True(resetNotificationOccured);
}
public void ChangeViewAttributeFilterTriggersNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
Assert.Throws <NotSupportedException>(delegate { view.RowFilter = "FeatureName LIKE 'A m*'"; });
Assert.True(resetNotificationOccured);
}
public void BeginExecuteQueryPollingNotification()
{
MockRepository mocks = new MockRepository();
IFeatureProvider adapted = mocks.CreateMock <IFeatureProvider>();
IExtents iExtentsStub =
MockRepository.GenerateStub <IExtents>();
FeatureQueryExpression featureQueryExpressionStub =
MockRepository.GenerateStub <FeatureQueryExpression>(iExtentsStub, SpatialOperation.Intersects);
_returnReaderStub = MockRepository.GenerateStub <IFeatureDataReader>();
_sleepInterval = 1000;
using (mocks.Unordered())
{
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub))
.Do(new ExecuteQueryDelegate(executeQueryMock));
}
mocks.ReplayAll();
AsyncFeatureProviderAdapter adapter = new AsyncFeatureProviderAdapter(adapted);
IAsyncResult ar = adapter.BeginExecuteQuery(featureQueryExpressionStub, null);
Assert.NotNull(ar);
Assert.False(ar.IsCompleted);
while (!ar.IsCompleted)
{
Thread.Sleep(350);
}
Assert.True(ar.IsCompleted);
Assert.Same(_returnReaderStub, adapter.EndExecuteQuery(ar));
mocks.VerifyAll();
}
public void SettingOidFilterAllowsOnlyFeaturesContainingFilteredOidsInView()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable <Guid> table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Guid[] ids = new Guid[3];
ids[0] = (table.Rows[1] as FeatureDataRow <Guid>).Id;
ids[1] = (table.Rows[4] as FeatureDataRow <Guid>).Id;
ids[2] = (table.Rows[6] as FeatureDataRow <Guid>).Id;
FeatureDataView view = new FeatureDataView(table);
view.OidFilter = new OidCollectionExpression(ids);
Assert.Equal(3, view.Count);
Assert.True(view.Find(ids[0]) > -1);
Assert.True(view.Find(ids[1]) > -1);
Assert.True(view.Find(ids[2]) > -1);
Assert.Equal(-1, view.Find((table.Rows[0] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[2] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[3] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[5] as FeatureDataRow <Guid>).Id));
}
public void ExecuteIntersectionQueryByBoundingBoxWhenClosedThrowsExceptionTest()
{
ShapeFileProvider shapeFile = new ShapeFileProvider(
BcRoadsShapeFile, _geoFactory, _coordSysFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(shapeFile.GetExtents());
IFeatureDataReader reader = shapeFile.ExecuteFeatureQuery(query);
}
public void IFeatureProviderMethodsPassThroughAdapter()
{
MockRepository mocks = new MockRepository();
IFeatureProvider adapted = mocks.CreateMock <IFeatureProvider>();
IGeometryFactory iGeometryFactoryStub =
MockRepository.GenerateStub <IGeometryFactory>();
FeatureDataTable featureDataTableStub =
MockRepository.GenerateStub <FeatureDataTable>(iGeometryFactoryStub);
IFeatureDataReader iFeatureDataReaderStub =
MockRepository.GenerateStub <IFeatureDataReader>();
IExtents iExtentsStub =
MockRepository.GenerateStub <IExtents>();
FeatureQueryExpression featureQueryExpressionStub =
MockRepository.GenerateStub <FeatureQueryExpression>(iExtentsStub, SpatialOperation.Intersects);
FeatureQueryExecutionOptions featureQueryExecutionOptionsStub =
new FeatureQueryExecutionOptions();
DataTable dataTableStub =
MockRepository.GenerateStub <DataTable>();
CultureInfo cultureInfoStub =
MockRepository.GenerateStub <CultureInfo>(1);
using (mocks.Unordered())
{
Expect.Call(adapted.CreateNewTable())
.Return(featureDataTableStub);
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub, featureQueryExecutionOptionsStub))
.Return(iFeatureDataReaderStub);
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub))
.Return(iFeatureDataReaderStub);
adapted.GeometryFactory = iGeometryFactoryStub;
Expect.Call(adapted.GeometryFactory)
.Return(iGeometryFactoryStub);
Expect.Call(adapted.GetFeatureCount())
.Return(3);
Expect.Call(adapted.GetSchemaTable())
.Return(dataTableStub);
Expect.Call(adapted.Locale)
.Return(cultureInfoStub);
adapted.SetTableSchema(featureDataTableStub);
}
mocks.ReplayAll();
AsyncFeatureProviderAdapter adapter = new AsyncFeatureProviderAdapter(adapted);
Assert.Same(featureDataTableStub, adapter.CreateNewTable());
Assert.Same(iFeatureDataReaderStub,
adapter.ExecuteFeatureQuery(featureQueryExpressionStub, featureQueryExecutionOptionsStub));
Assert.Same(iFeatureDataReaderStub,
adapter.ExecuteFeatureQuery(featureQueryExpressionStub));
adapter.GeometryFactory = iGeometryFactoryStub;
Assert.Same(iGeometryFactoryStub, adapter.GeometryFactory);
Assert.Equal(3, adapter.GetFeatureCount());
Assert.Same(dataTableStub, adapter.GetSchemaTable());
Assert.Same(cultureInfoStub, adapter.Locale);
adapter.SetTableSchema(featureDataTableStub);
mocks.VerifyAll();
}
public void InsertFeatureTest()
{
FeatureDataTable <UInt32> schema = new FeatureDataTable <UInt32>("oid", _geoFactory);
schema.Columns.AddRange(new DataColumn[]
{
new DataColumn("Name", typeof(String)),
new DataColumn("DateCreated", typeof(DateTime)),
new DataColumn("Visits", typeof(Int32)),
new DataColumn("Weight", typeof(Single))
});
ShapeFileProvider shapeFile = ShapeFileProvider.Create("UnitTestData", "Test2", ShapeType.Point, schema, _geoFactory);
shapeFile.Open();
DateTime dateCreated = DateTime.Now;
FeatureDataRow <UInt32> feature = schema.NewRow(1);
feature["Name"] = "Test feature";
feature["DateCreated"] = dateCreated;
feature["Visits"] = 0;
feature["Weight"] = 100.0f;
feature.Geometry = _geoFactory.CreatePoint2D(1, 1);
shapeFile.Insert(feature);
shapeFile.Close();
shapeFile = new ShapeFileProvider(@"UnitTestData\Test2.shp", _geoFactory);
shapeFile.Open();
Assert.AreEqual(1, shapeFile.GetFeatureCount());
FeatureDataTable dataTable = new FeatureDataTable("ShapeFile test", _geoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(_geoFactory.CreateExtents2D(0.9, 0.9, 1, 1));
IFeatureDataReader reader = shapeFile.ExecuteFeatureQuery(query);
dataTable.Load(reader, LoadOption.OverwriteChanges, null);
Assert.AreEqual(1, dataTable.Rows.Count);
FeatureDataRow newFeature = dataTable.Rows[0] as FeatureDataRow;
Assert.AreEqual(_geoFactory.CreatePoint2D(1, 1), newFeature.Geometry);
Assert.AreEqual(newFeature["Name"], "Test feature");
DateTime dateCreatedActual = (DateTime)newFeature["DateCreated"];
Assert.AreEqual(dateCreatedActual.Year, dateCreated.Year);
Assert.AreEqual(dateCreatedActual.Month, dateCreated.Month);
Assert.AreEqual(dateCreatedActual.Day, dateCreated.Day);
Assert.AreEqual(newFeature["Visits"], 0);
Assert.AreEqual(newFeature["Weight"], 100.0f);
shapeFile.Close();
}
public void DefaultViewReturnsAllRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader);
Assert.Equal(table.Rows.Count, table.DefaultView.Count);
}
public void AddNewRowThrowsNotSupported()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Assert.Throws <NotSupportedException>(delegate { view.AddNew(); });
}
public void CreatingDataViewReturnsValidDataView()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Assert.IsType(typeof(FeatureDataTable), view.Table);
Assert.Same(table, view.Table);
}
public void SpatialQueryTypeIsWhatIsSpecifiedAtCreateTime()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
IGeometry filter = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
FeatureDataView view = new FeatureDataView(table, filter, "", DataViewRowState.CurrentRows);
Assert.Equal(SpatialOperation.Intersects, view.SpatialFilter.Op);
}
public void ExecuteIntersectionQueryByBoundingBoxTest()
{
ShapeFileProvider shapeFile = new ShapeFileProvider(
BcRoadsShapeFile, _geoFactory, _coordSysFactory);
shapeFile.Open();
FeatureDataTable data = new FeatureDataTable("ShapeFile test", _geoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(shapeFile.GetExtents());
IFeatureDataReader reader = shapeFile.ExecuteFeatureQuery(query);
data.Load(reader, LoadOption.OverwriteChanges, null);
Assert.AreEqual(shapeFile.GetFeatureCount(), data.Rows.Count);
shapeFile.Close();
}
public void CreatingDataViewWithEqualsSpatialExpressionSucceeds()
{
// This test is here so that when it is supported, the test breaks and is rewritten
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Point <BufferedCoordinate> empty = _factories.GeoFactory.CreatePoint() as Point <BufferedCoordinate>;
new FeatureDataView(table, empty, SpatialOperation.Equals, "", DataViewRowState.CurrentRows);
}
private void createDataViewOnNewTable(out FeatureDataView view,
out FeatureDataTable <Guid> table,
Boolean includeGeometryCollections)
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory,
includeGeometryCollections);
table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
view = new FeatureDataView(table);
}
public IExtents GetExtentsByOid(TOid oid)
{
FeatureQueryExpression query =
new FeatureQueryExpression(new AttributesProjectionExpression(new[] { GeometryColumn }),
null, null, new OidCollectionExpression(new[] { oid }), null);
using (IFeatureDataReader fdr = ExecuteFeatureQuery(query))
{
while (fdr.Read())
{
return((IExtents)fdr.Geometry.Extents.Clone());
}
}
return(GeometryFactory.CreateExtents());
}
public void MergeSchemaToSchemalessTargetShouldCreateIdenticalTable()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable target = new FeatureDataTable(_factories.GeoFactory);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
public void MergeSchemaToKeyedTableWithDifferentKeyNameButSameTypeShouldKeepKeyButAddOtherColumns()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable <Guid> target = new FeatureDataTable <Guid>("GID", _factories.GeoFactory);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
public void CloneToCopiesTableStructureAndNoData()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable clone = new FeatureDataTable(_factories.GeoFactory);
table.CloneTo(clone);
DataTableHelper.AssertTableStructureIdentical(table, clone);
Assert.Equal(0, clone.Rows.Count);
}
//[ExpectedException(typeof (NotImplementedException))]
public void DataViewManagerIsAFeatureDataViewManager()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataSet dataSet = new FeatureDataSet(_factories.GeoFactory);
dataSet.Tables.Add(table);
FeatureDataView view = dataSet.DefaultViewManager.CreateDataView(table);
Assert.NotNull(view.DataViewManager);
Assert.IsType(typeof(FeatureDataViewManager), view.DataViewManager);
}
public void SettingGeometryFilterToIdenticalGeometryDoesntChangeFilterObject()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
IGeometry filter = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
FeatureDataView view = new FeatureDataView(table, filter, "", DataViewRowState.CurrentRows);
IGeometry filterCopy = filter.Clone();
Assert.NotSame(filter, filterCopy);
Assert.Equal(filter, filterCopy);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(filterCopy);
view.SpatialFilter = expression;
Assert.NotSame(expression, view.SpatialFilter);
}
public IGeometry GetGeometryByOid(TOid oid)
{
FeatureQueryExpression exp
= new FeatureQueryExpression(
new AttributesProjectionExpression(
new[]
{
GeometryColumn
}), null, null, new OidCollectionExpression(new[] { oid }), null);
using (IFeatureDataReader reader = ExecuteFeatureQuery(exp))
{
foreach (IFeatureDataRecord fdr in reader)
{
return(fdr.Geometry.Clone());
}
}
return(null);
}
public void TestGeometryProvider()
{
string wkt;
GeometryServices g = new GeometryServices();
GeometryProvider prov;
IGeometry geom = g.DefaultGeometryFactory.WktReader.Read(File.ReadAllText("D:\\geometries.txt"));
prov = new GeometryProvider(new[] { geom });
using (IFeatureDataReader fdr =
prov.ExecuteFeatureQuery(new FeatureQueryExpression(geom.Extents, SpatialOperation.Intersects)))
{
while (fdr.Read())
{
Debug.WriteLine(fdr.Geometry.AsText());
}
}
}
protected override Int32 Fill(DataTable[] dataTables, IDataReader dataReader, Int32 startRecord, Int32 maxRecords)
{
if (dataTables.Length == 0)
{
return(0);
}
Int32 tableIndex = 0;
IFeatureDataReader featureReader = dataReader as IFeatureDataReader;
if (featureReader == null)
{
throw new ArgumentException("Parameter 'dataReader' " +
"must be a IFeatureDataReader instance.");
}
do
{
FeatureDataTable table = dataTables[tableIndex] as FeatureDataTable;
if (table == null)
{
throw new ArgumentException("Components of 'dataTables' must be " +
"FeatureDataTable instances.");
}
if (table.Columns.Count == 0)
{
FillSchema(table, SchemaType.Mapped, featureReader);
}
table.Merge((IEnumerable <IFeatureDataRecord>)featureReader, null, _factory, SchemaMergeAction.AddWithKey | SchemaMergeAction.CaseInsensitive);
tableIndex++;
} while (dataReader.NextResult());
return(dataTables[0].Rows.Count);
}
public IFeatureDataRecord GetFeatureByOid(TOid oid)
{
FeatureQueryExpression exp
= new FeatureQueryExpression(
new AllAttributesExpression(), null, null, new OidCollectionExpression(new[] { oid }), null);
using (IFeatureDataReader reader = ExecuteFeatureQuery(exp))
{
FeatureDataTable fdt = new FeatureDataTable <TOid>("features", OidColumn, GeometryFactory);
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
if (name != OidColumn)
{
fdt.Columns.Add(name, reader.GetFieldType(i));
}
}
foreach (IFeatureDataRecord fdr in reader)
{
FeatureDataRow row = fdt.NewRow();
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
row[name] = reader[i];
}
if ((fdr as SpatialDbFeatureDataReader).HasGeometry)
{
row.Geometry = reader.Geometry;
}
fdt.AddRow(row);
return(row);
}
}
return(null);
}
public void ExecutingQueryOnTableTriggersViewListChangedResetNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents dataExtents = data.GetExtents();
IExtents halfBounds = _factories.GeoFactory.CreateExtents(
dataExtents.Min, dataExtents.Max);
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(halfBounds);
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
addNotificationOccured = true;
}
};
IExtents otherHalfBounds = _factories.GeoFactory.CreateExtents(
dataExtents.Min, dataExtents.Max);
otherHalfBounds.TranslateRelativeToWidth(0.5, 0.5);
otherHalfBounds.Scale(0.5);
query = FeatureQueryExpression.Intersects(otherHalfBounds);
reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Assert.True(addNotificationOccured);
}
private void Export(string colName)
{
ExportDirectory = Path.Combine(Path.GetDirectoryName(Provider.Filename),
Path.GetFileNameWithoutExtension(Provider.Filename) + "_Export");
if (!Directory.Exists(ExportDirectory))
{
Directory.CreateDirectory(ExportDirectory);
}
FeatureDataTable fdt = Provider.CreateNewTable();
IFeatureDataReader reader = Provider.GetReader();
while (reader.Read())
{
string layerName = GenerateUniqueName(reader[colName].ToString());
using (
ShapeFileProvider export = ShapeFileProvider.Create(ExportDirectory, layerName,
Provider.ShapeType, Provider.CreateNewTable(),
Provider.GeometryFactory,
_geometryServices.CoordinateSystemFactory))
{
export.IsSpatiallyIndexed = false;
export.Open();
FeatureDataRow <uint> fdr = (FeatureDataRow <uint>)fdt.NewRow();
object[] vals = new object[fdt.Columns.Count];
reader.GetValues(vals);
fdr.ItemArray = vals;
fdr.Geometry = reader.Geometry;
export.Insert(fdr);
export.Close();
}
}
}
public Int32 Fill(ICollection<FeatureDataTable> dataTables, IFeatureDataReader dataReader)
{
FeatureDataTable[] tables = new FeatureDataTable[dataTables.Count];
dataTables.CopyTo(tables, 0);
return Fill(tables, dataReader, 0, 0);
}
public Int32 Fill(FeatureDataTable table, IFeatureDataReader dataReader)
{
return Fill(new FeatureDataTable[] { table }, dataReader);
}
public void BeginExecuteQueryBlockUntilDone()
{
MockRepository mocks = new MockRepository();
IFeatureProvider adapted = mocks.CreateMock<IFeatureProvider>();
IExtents iExtentsStub =
MockRepository.GenerateStub<IExtents>();
FeatureQueryExpression featureQueryExpressionStub =
MockRepository.GenerateStub<FeatureQueryExpression>(iExtentsStub, SpatialOperation.Intersects);
_returnReaderStub = MockRepository.GenerateStub<IFeatureDataReader>();
_sleepInterval = 750;
using (mocks.Unordered())
{
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub))
.Do(new ExecuteQueryDelegate(executeQueryMock));
}
mocks.ReplayAll();
AsyncFeatureProviderAdapter adapter = new AsyncFeatureProviderAdapter(adapted);
IAsyncResult ar = adapter.BeginExecuteQuery(featureQueryExpressionStub, null);
Assert.NotNull(ar);
Stopwatch timer = Stopwatch.StartNew();
Assert.Same(_returnReaderStub, adapter.EndExecuteQuery(ar));
timer.Stop();
Assert.True(ar.IsCompleted);
Assert.False(ar.CompletedSynchronously);
Assert.True(timer.ElapsedMilliseconds > 500L);
mocks.VerifyAll();
}
public void BeginExecuteQueryPollingNotification()
{
MockRepository mocks = new MockRepository();
IFeatureProvider adapted = mocks.CreateMock<IFeatureProvider>();
IExtents iExtentsStub =
MockRepository.GenerateStub<IExtents>();
FeatureQueryExpression featureQueryExpressionStub =
MockRepository.GenerateStub<FeatureQueryExpression>(iExtentsStub, SpatialOperation.Intersects);
_returnReaderStub = MockRepository.GenerateStub<IFeatureDataReader>();
_sleepInterval = 1000;
using (mocks.Unordered())
{
Expect.Call(adapted.ExecuteFeatureQuery(featureQueryExpressionStub))
.Do(new ExecuteQueryDelegate(executeQueryMock));
}
mocks.ReplayAll();
AsyncFeatureProviderAdapter adapter = new AsyncFeatureProviderAdapter(adapted);
IAsyncResult ar = adapter.BeginExecuteQuery(featureQueryExpressionStub, null);
Assert.NotNull(ar);
Assert.False(ar.IsCompleted);
while (!ar.IsCompleted)
{
Thread.Sleep(350);
}
Assert.True(ar.IsCompleted);
Assert.Same(_returnReaderStub, adapter.EndExecuteQuery(ar));
mocks.VerifyAll();
}
