/* Test insert/update/select (but not setting/getting any lock info) on a table that supports locking. */
void BasicUpdateTests::update_on_lock_enabled_table ()
{
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcov());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaSample(), ArcSDETestConfig::ClassNameSample(), true);
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameSample());
FdoPtr<FdoPropertyValueCollection> values = insert->GetPropertyValues ();
FdoPtr<FdoStringValue> expression = FdoStringValue::Create (L"Zozo");
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create (AdjustRdbmsName(L"LockProperty"), expression);
values->Add (value);
FdoPtr<FdoIFeatureReader> reader = insert->Execute ();
FdoInt32 newId = 0;
if (reader->ReadNext())
newId = reader->GetInt32(AdjustRdbmsName(L"Id"));
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameSample());
wchar_t filter[1024];
FdoCommonOSUtil::swprintf(filter, ELEMENTS(filter), L"%ls = %d", AdjustRdbmsName(L"Id"), newId);
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
values = update->GetPropertyValues ();
value = FdoPropertyValue::Create ();
value->SetName (AdjustRdbmsName(L"LockProperty"));
value->SetValue (L"'All mimsy were the borogoves'");
values->Add (value);
if (1 != update->Execute ())
CPPUNIT_FAIL ("update execute failed");
// check by doing a select
FdoPtr<FdoISelect> select = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
select->SetFeatureClassName (ArcSDETestConfig::QClassNameSample());
reader = select->Execute ();
while (reader->ReadNext ())
{
CPPUNIT_ASSERT_MESSAGE ("incorrect value", 0 == wcscmp (L"All mimsy were the borogoves", reader->GetString (AdjustRdbmsName(L"LockProperty"))));
}
reader->Close();
// Clean up after test:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassSimple(), ArcSDETestConfig::ClassNameSample(), true);
mConnection->Close();
}
catch (FdoException* ge)
{
fail (ge);
}
}
void FdoSchemaRollbackTest::ModAcadSchema( FdoIConnection* connection )
{
/* Test modifying an existing schema */
FdoPtr<FdoIDescribeSchema> pDescCmd = (FdoIDescribeSchema*) connection->CreateCommand(FdoCommandType_DescribeSchema);
pDescCmd->SetSchemaName( L"Electric'l" );
FdoFeatureSchemasP pSchemas = pDescCmd->Execute();
FdoPtr<FdoIApplySchema> pCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
FdoPtr<FdoFeatureSchema> pSchema = pSchemas->GetItem( L"Acad" );
FdoPtr<FdoFeatureClass> pClass = (FdoFeatureClass*) (FdoClassesP(pSchema->GetClasses())->GetItem(L"AcDbEntity"));
FdoPtr<FdoClass> pRefClass = (FdoClass*) (FdoClassesP(pSchema->GetClasses())->GetItem(L"Entity"));
// Test delete of property
FdoPtr<FdoDataPropertyDefinition> pProp = (FdoDataPropertyDefinition*) (FdoPropertiesP(pClass->GetProperties())->GetItem(L"ColourIndex"));
pProp->Delete();
pProp = (FdoDataPropertyDefinition*) (FdoPropertiesP(pRefClass->GetProperties())->GetItem(L"ColourIndex"));
pProp->Delete();
// Test adding data property to existing class.
pProp = FdoDataPropertyDefinition::Create( L"Plot Style", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(20);
pProp->SetNullable(!mCanAddNotNullCol);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Plot Style", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(20);
pProp->SetNullable(!mCanAddNotNullCol);
FdoPropertiesP(pRefClass->GetProperties())->Add( pProp );
pClass = (FdoFeatureClass*) (FdoClassesP(pSchema->GetClasses())->GetItem(L"AcDbHatch"));
FdoPtr<FdoObjectPropertyDefinition> pObjProp = (FdoObjectPropertyDefinition*) FdoPropertiesP(pClass->GetProperties())->GetItem(L"edges");
pObjProp->Delete();
pRefClass = (FdoClass*) (FdoClassesP(pSchema->GetClasses())->GetItem(L"AcDbVertexData"));
pObjProp = (FdoObjectPropertyDefinition*) FdoPropertiesP(pRefClass->GetProperties())->GetItem(L"point");
pObjProp->Delete();
pCmd->SetFeatureSchema( pSchema );
pCmd->Execute();
}
void SuperMapSelectTest::select_no_featureclass()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
Select->SetFeatureClassName(L"");
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
}
/////////////////////////////////////////////////////////////////////
//
// namespace GwsCommonFdoUtils
//
/////////////////////////////////////////////////////////////////////
void GwsCommonFdoUtils::GetClassDefinition (
FdoIConnection * pConn,
const GWSQualifiedName & classname,
FdoFeatureSchema * & schema,
FdoClassDefinition * & classDef
)
{
FdoPtr<FdoIDescribeSchema> descSchema =
(FdoIDescribeSchema *) pConn->CreateCommand (FdoCommandType_DescribeSchema);
FdoString* schemaName = classname.Schema();
FdoString* clsName = classname.Name();
if (NULL != schemaName && ::wcslen(schemaName) > 0)
{
descSchema->SetSchemaName(schemaName);
}
if (NULL != clsName && ::wcslen(clsName) > 0)
{
FdoPtr<FdoStringCollection> classNames = FdoStringCollection::Create();
classNames->Add(clsName);
descSchema->SetClassNames(classNames.p);
}
FdoPtr <FdoFeatureSchemaCollection> schemas =
(FdoFeatureSchemaCollection *) descSchema->Execute ();
schema = (FdoFeatureSchema *)schemas->GetItem (schemaName);
FdoPtr<FdoClassCollection> pClasses = schema->GetClasses();
classDef = pClasses->GetItem(clsName);
}
// Exports spatial contexts and feature schemas from datastore to XML.
void FdoImportExportTest::Export( FdoIConnection* connection, FdoIoStream* stream, FdoXmlSpatialContextFlags* flags )
{
stream->Reset();
FdoXmlWriterP writer = FdoXmlWriter::Create(stream);
// Serialize the spatial contexts
FdoXmlSpatialContextSerializer::XmlSerialize(
connection,
FdoXmlSpatialContextWriterP(
FdoXmlSpatialContextWriter::Create(writer,flags)
),
flags
);
// Get the feature schemas from the Datastore
FdoPtr<FdoIDescribeSchema> pDescCmd = (FdoIDescribeSchema*) connection->CreateCommand(FdoCommandType_DescribeSchema);
FdoFeatureSchemasP schemas = pDescCmd->Execute();
// Serialize the feature schemas.
schemas->WriteXml( writer );
// Get the feature schema overrides from the Datastore
FdoPtr<FdoIDescribeSchemaMapping> pDescMappingsCmd = (FdoIDescribeSchemaMapping*) connection->CreateCommand(FdoCommandType_DescribeSchemaMapping);
FdoSchemaMappingsP mappings = pDescMappingsCmd->Execute();
// Serialize the feature schemas.
mappings->WriteXml( writer );
FdoFeatureSchemaP selSchema = schemas->FindItem( L"Schema1" );
if ( selSchema ) {
FdoClassDefinitionP selClass = FdoClassesP(selSchema->GetClasses())->FindItem( L"ClassB1" );
if ( selClass ) {
FdoPtr<FdoISelect> selCmd = (FdoISelect*) connection->CreateCommand( FdoCommandType_Select );
selCmd->SetFeatureClassName(selClass->GetQualifiedName());
FdoPtr<FdoIFeatureReader> rdr = selCmd->Execute();
FdoXmlFeatureFlagsP featureFlags = FdoXmlFeatureFlags::Create();
featureFlags->SetDefaultNamespace( FdoStringP(L"http://") + (featureFlags->GetUrl()) + L"/Schema1" );
FdoXmlFeatureWriterP featureWriter = FdoXmlFeatureWriter::Create(writer, featureFlags);
FdoXmlFeatureSerializer::XmlSerialize( rdr, featureWriter, featureFlags );
}
}
}
void FdoImportExportTest::Test8 ()
{
try {
FdoIoStreamP configStream = FdoIoMemoryStream::Create();
CreateConfigBadWkt( configStream );
// Test 8 tries adding a spatial context whose WKT differs
// from what Oracle defines for its coordinate system.
// This test should fail for Oracle and pass for the others.
printf( "Test8 (junk WKT) ... \n" );
printf( "\tOpening Source Connection ... \n" );
FdoPtr<FdoIConnection> connection = UnitTestUtil::CreateConnection(
true,
true,
DB_NAME_SRC_SUFFIX,
NULL,
NULL,
0
);
FdoPtr<FdoIConnectionCapabilities> cap = connection->GetConnectionCapabilities();
// Import from the input XML document
printf( "\tImporting ...\n" );
Import(
connection,
configStream,
NULL,
true,
false
);
FdoPtr<FdoIGetSpatialContexts> cmd = (FdoIGetSpatialContexts*) connection->CreateCommand( FdoCommandType_GetSpatialContexts );
cmd->SetActiveOnly(false);
FdoPtr<FdoISpatialContextReader> reader = cmd->Execute();
while ( reader->ReadNext() ) {
// Skip default spatial context if not writing it.
if ( wcscmp(reader->GetName(), L"Manhole1") == 0 ) {
if ( cap->SupportsCSysWKTFromCSysName() )
CPPUNIT_ASSERT( wcscmp(reader->GetCoordinateSystemWkt(), L"LOCAL_CS [ \"Non-Earth (Meter)\", LOCAL_DATUM [\"Local Datum\", 0], UNIT [\"Meter\", 1.0], AXIS [\"X\", EAST], AXIS[\"Y\", NORTH]]") == 0 );
else
CPPUNIT_ASSERT( wcscmp(reader->GetCoordinateSystemWkt(), L"nonsense wkt") == 0 );
}
}
}
catch ( FdoException* e )
{
UnitTestUtil::FailOnException( e );
}
printf( "Done\n" );
}
///<summary>Executes the destroy schema command, which removes the schema, class
///definitions, relation definitions, and all instance data from the DataStore.
///If elements in other schemas refer to the schema to be destroyed
///an exception is thrown.</summary>
/// <returns>Returns nothing</returns>
void SuperMapDestroySchemaCommand::Execute ()
{
TRACE(_T("µ÷ÓÃ SuperMapDestroySchemaCommand::Execute [%ls]¡£\n"), m_SchemaName);
FdoPtr<FdoFeatureSchema> schema = FdoFeatureSchema::Create (m_SchemaName, L"");
schema->Delete ();
FdoPtr<FdoIApplySchema> apply = (FdoIApplySchema*)mConnection->CreateCommand (FdoCommandType_ApplySchema);
apply->SetFeatureSchema (schema);
apply->Execute ();
}
int MgdUpdateFeaturesCommand::ExecuteUpdate(MgResourceIdentifier* resource, CREFSTRING className, MgPropertyCollection* propertyValues, CREFSTRING filter, MgTransaction* trans)
{
int updated = 0;
MG_FEATURE_SERVICE_TRY()
CHECK_FEATURE_SOURCE_ARGUMENT(resource, L"MgdUpdateFeaturesCommand::ExecuteUpdate");
CHECKARGUMENTNULL(propertyValues, L"MgdUpdateFeaturesCommand::ExecuteUpdate");
if (className.empty())
throw new MgNullArgumentException(L"MgdUpdateFeaturesCommand::ExecuteUpdate", __LINE__, __WFILE__, NULL, L"", NULL);
Ptr<MgdFeatureConnection> connWrap;
FdoPtr<FdoIConnection> conn;
FdoPtr<FdoITransaction> fdoTrans;
Ptr<MgdTransaction> mgTrans = dynamic_cast<MgdTransaction*>(trans);
if (NULL != mgTrans)
{
SAFE_ADDREF(mgTrans.p);
Ptr<MgResourceIdentifier> origFeatureSource = mgTrans->GetFeatureSource();
//Check that the transaction originates from the same feature source
if (origFeatureSource->ToString() != resource->ToString())
throw new MgInvalidArgumentException(L"MgdUpdateFeaturesCommand::ExecuteUpdate", __LINE__, __WFILE__, NULL, L"", NULL);
connWrap = mgTrans->GetConnection(); //Connection is already open
fdoTrans = mgTrans->GetFdoTransaction();
}
else
{
connWrap = new MgdFeatureConnection(resource);
}
conn = connWrap->GetConnection();
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)conn->CreateCommand(FdoCommandType_Update);
update->SetFeatureClassName(className.c_str());
if (!filter.empty())
update->SetFilter(filter.c_str());
if (NULL != fdoTrans.p)
update->SetTransaction(fdoTrans);
FdoPtr<FdoPropertyValueCollection> propVals = update->GetPropertyValues();
for (INT32 i = 0; i < propertyValues->GetCount(); i++)
{
Ptr<MgProperty> mgp = propertyValues->GetItem(i);
FdoPtr<FdoPropertyValue> pv = MgdFeatureUtil::MgPropertyToFdoProperty(mgp);
propVals->Add(pv);
}
updated = update->Execute();
MG_FEATURE_SERVICE_CATCH_AND_THROW_WITH_FEATURE_SOURCE(L"MgdUpdateFeaturesCommand::ExecuteUpdate", resource)
return updated;
}
void MgdCreateFileFeatureSource::CreateDataStore(
FdoIConnection* conn)
{
MG_FEATURE_SERVICE_TRY()
m_tempFileName = MgFileUtil::GenerateTempFileName(true, STRING(L"tmp"), m_fileExtension); // NOXLATE
// Create the datastore
FdoPtr<FdoICreateDataStore> createDsCmd = static_cast<FdoICreateDataStore*>(conn->CreateCommand(FdoCommandType_CreateDataStore));
FdoPtr<FdoIDataStorePropertyDictionary> dsProp = createDsCmd->GetDataStoreProperties();
dsProp->SetProperty (m_connectParamName.c_str(), m_tempFileName.c_str());
createDsCmd->Execute();
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgdCreateFileFeatureSource::CreateDataStore")
}
EGwsStatus GwsCommonFdoUtils::DescribeSC (
FdoIConnection * conn,
FdoString * scname,
GwsSpatialContextDescription & scdesc
)
{
FdoPtr<FdoIGetSpatialContexts> cmd;
FdoPtr<FdoISpatialContextReader> reader;
scdesc.SetClassName (GWSQualifiedName ());
scdesc.SetPropertyName (NULL);
scdesc.SetSpatialContextName (NULL);
scdesc.SetSpatialContextDesc (NULL);
scdesc.SetCsNameWkt (NULL);
if (scname == NULL || * scname == 0)
return eGwsOk;
try {
cmd = (FdoIGetSpatialContexts *) conn->CreateCommand (FdoCommandType_GetSpatialContexts);
reader = cmd->Execute ();
while (reader->ReadNext ()) {
if (wcscmp (reader->GetName (), scname) == 0) {
FdoString * cswkt = reader->GetCoordinateSystemWkt ();
FdoString * desc = reader->GetDescription ();
double xytol = reader->GetXYTolerance();
scdesc.SetCsNameWkt (cswkt);
scdesc.SetSpatialContextDesc (desc);
scdesc.SetSpatialContextName (scname);
scdesc.SetXYTolerance(xytol);
FdoPtr<FdoByteArray> pByteArray = reader->GetExtent();
if (pByteArray) {
FdoPtr<FdoFgfGeometryFactory> pAwkbFactory = FdoFgfGeometryFactory::GetInstance();
FdoPtr<FdoIGeometry> pGeometry = pAwkbFactory->CreateGeometryFromFgf(pByteArray);
FdoPtr<FdoIEnvelope> pEnvelope = pGeometry->GetEnvelope();
scdesc.SetExtents (pEnvelope);
}
return eGwsOk;
}
}
return eGwsSCNotFound;
} catch (FdoException * fdoEx) {
fdoEx->Release ();
}
// in case when exception thrown, assume that sc are not
// supported.
return eGwsNotSupported;
}
///<summary>Executes the destroy schema command, which removes the schema, class
///definitions, relation definitions, and all instance data from the DataStore.
///If elements in other schemas refer to the schema to be destroyed
///an exception is thrown.</summary>
/// <returns>Returns nothing</returns>
void ArcSDEDestroySchemaCommand::Execute ()
{
FdoPtr<ArcSDEConnection> connection;
// verify the connection
connection = static_cast<ArcSDEConnection*>(GetConnection ());
if (connection == NULL)
throw FdoException::Create (NlsMsgGet (ARCSDE_CONNECTION_NOT_ESTABLISHED, "Connection not established."));
FdoPtr<FdoIDescribeSchema> describe = (FdoIDescribeSchema*)connection->CreateCommand (FdoCommandType_DescribeSchema);
describe->SetSchemaName (mSchemaName->GetName ());
FdoPtr<FdoFeatureSchemaCollection> schemas = describe->Execute ();
FdoPtr<FdoFeatureSchema> schema = schemas->GetItem (0);
FdoPtr<FdoClassCollection> classes = schema->GetClasses ();
// for now, to delete a schema, just delete all the classes
for (int i = 0; i < classes->GetCount (); i++)
{
FdoPtr<FdoClassDefinition> feature = classes->GetItem (i);
feature->Delete ();
}
FdoPtr<FdoIApplySchema> apply = (FdoIApplySchema*)connection->CreateCommand (FdoCommandType_ApplySchema);
apply->SetFeatureSchema (schema);
apply->Execute ();
}
int MgdUpdateFeaturesCommand::ExecuteDelete(MgResourceIdentifier* resource, CREFSTRING className, CREFSTRING filter, MgTransaction* trans)
{
int deleted = 0;
MG_FEATURE_SERVICE_TRY()
CHECK_FEATURE_SOURCE_ARGUMENT(resource, L"MgdUpdateFeaturesCommand::ExecuteDelete");
if (className.empty())
throw new MgNullArgumentException(L"MgdUpdateFeaturesCommand::ExecuteDelete", __LINE__, __WFILE__, NULL, L"", NULL);
Ptr<MgdFeatureConnection> connWrap;
FdoPtr<FdoIConnection> conn;
FdoPtr<FdoITransaction> fdoTrans;
Ptr<MgdTransaction> mgTrans = dynamic_cast<MgdTransaction*>(trans);
if (NULL != mgTrans)
{
SAFE_ADDREF(mgTrans.p);
Ptr<MgResourceIdentifier> origFeatureSource = mgTrans->GetFeatureSource();
//Check that the transaction originates from the same feature source
if (origFeatureSource->ToString() != resource->ToString())
throw new MgInvalidArgumentException(L"MgdUpdateFeaturesCommand::ExecuteDelete", __LINE__, __WFILE__, NULL, L"", NULL);
connWrap = mgTrans->GetConnection(); //Connection is already open
fdoTrans = mgTrans->GetFdoTransaction();
}
else
{
connWrap = new MgdFeatureConnection(resource);
}
conn = connWrap->GetConnection();
FdoPtr<FdoIDelete> fdoDelete = (FdoIDelete*)conn->CreateCommand(FdoCommandType_Delete);
fdoDelete->SetFeatureClassName(className.c_str());
if (!filter.empty())
fdoDelete->SetFilter(filter.c_str());
if (NULL != fdoTrans.p)
fdoDelete->SetTransaction(fdoTrans);
deleted = fdoDelete->Execute();
MG_FEATURE_SERVICE_CATCH_AND_THROW_WITH_FEATURE_SOURCE(L"MgdUpdateFeaturesCommand::ExecuteDelete", resource)
return deleted;
}
void ConvertUtil::CreateSQLiteFile(FdoIConnection *connection, FdoString *file)
{
_wunlink(file);
int count = 0;
wchar_t buffer[512];
FdoString **names = NULL;
swprintf(buffer, 512, L"File=%ls;UseFdoMetadata=TRUE", file);
connection->SetConnectionString(buffer);
FdoPtr<FdoICreateDataStore> dataStore = static_cast<FdoICreateDataStore*>(connection->CreateCommand(FdoCommandType_CreateDataStore));
FdoPtr<FdoIDataStorePropertyDictionary> dictionary = dataStore->GetDataStoreProperties();
names = dictionary->GetPropertyNames(count);
dictionary->SetProperty(names[0], file);
dataStore->Execute();
}
void RfpTestRasterConversion::_setUp()
{
m_connection = CreateConnection();
CPPUNIT_ASSERT(m_connection != NULL);
FdoPtr<FdoIoStream> stream = FdoIoFileStream::Create(L"../../TestData/RGB/RGB.xml", L"r");
m_connection->SetConfiguration(stream);
m_connection->Open();
// execute the query
FdoICommand * cmd = m_connection->CreateCommand(FdoCommandType_Select);
FdoPtr<FdoISelect> cmdSelect = static_cast<FdoISelect*>(cmd);
cmdSelect->SetFeatureClassName(L"Photo");
FdoPtr<FdoIFeatureReader> reader = cmdSelect->Execute();
reader->ReadNext();
// get the raster
m_raster = reader->GetRaster(L"Image");
reader->Close();
}
void MySqlFdoInsertTest::charSetTestTable( FdoIConnection* connection, FdoString* charSet, FdoString* dataCharSet, FdoString* stringVal, FdoString* charVal )
{
FdoStringP className = FdoStringP::Format( L"%ls_%ls", charSet, dataCharSet );
FdoPtr<FdoIInsert> insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
FdoPtr<FdoPropertyValueCollection> propertyValues;
FdoPtr<FdoDataValue> dataValue;
FdoPtr<FdoPropertyValue> propertyValue;
insertCommand->SetFeatureClassName(className);
propertyValues = insertCommand->GetPropertyValues();
propertyValue = FdoPropertyValue::Create();
propertyValue->SetName( L"data" );
propertyValues->Add( propertyValue );
dataValue = FdoDataValue::Create(stringVal);
propertyValue->SetValue(dataValue);
propertyValue = FdoPropertyValue::Create();
propertyValue->SetName( L"chardata" );
propertyValues->Add( propertyValue );
dataValue = FdoDataValue::Create(charVal);
propertyValue->SetValue(dataValue);
FdoPtr<FdoIFeatureReader>rdr = insertCommand->Execute();
FdoPtr<FdoISelect>selCmd = (FdoISelect*)connection->CreateCommand( FdoCommandType_Select );
selCmd->SetFeatureClassName(className);
FdoPtr<FdoIFeatureReader>myReader = selCmd->Execute();
CPPUNIT_ASSERT( myReader->ReadNext() );
charSetVldValue( className, stringVal, myReader->GetString(L"data") );
charSetVldValue( className, charVal, myReader->GetString(L"chardata") );
CPPUNIT_ASSERT( !(myReader->ReadNext()) );
}
void CSuperMapGetSpatialContextsCommandTest::testExecute1()
{
// 测试WKT串是否正确只能通过MAP3D等来测，单元测试只测试对各种类型的坐标系空间语义读取器的迭代是否正确，是否出现死循环
try
{
CPPUNIT_ASSERT_MESSAGE("connection state not closed", FdoConnectionState_Closed == m_connection->GetConnectionState());
m_connection->SetConnectionString(L"DataSource=" L"\"type=sdb;database=" LOCATION L"普通平面坐标系\"");
CPPUNIT_ASSERT_MESSAGE("connection state not closed", FdoConnectionState_Closed == m_connection->GetConnectionState());
FdoConnectionState state = m_connection->Open();
CPPUNIT_ASSERT_MESSAGE("connection state not open", FdoConnectionState_Open == state);
CPPUNIT_ASSERT_MESSAGE("connection state not open", FdoConnectionState_Open == m_connection->GetConnectionState());
// Verify results of GetSpatialContext:
FdoPtr<FdoIGetSpatialContexts> getSpatialContexts = (FdoIGetSpatialContexts*)m_connection->CreateCommand(FdoCommandType_GetSpatialContexts);
//FdoPtr<FdoISpatialContextReader> spatialReader = getSpatialContexts->Execute();
// Get a SC reader
FdoPtr<FdoISpatialContextReader> reader = getSpatialContexts->Execute();
// Iterate ...
while ( reader->ReadNext() )
{
reader->GetExtent();
}
m_connection->Close();
CPPUNIT_ASSERT_MESSAGE("connection state not closed", FdoConnectionState_Closed == m_connection->GetConnectionState());
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(nex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
}
MgPropertyCollection* MgdUpdateFeaturesCommand::ExecuteInsert(MgResourceIdentifier* resource, CREFSTRING className, MgBatchPropertyCollection* batchPropertyValues, MgTransaction* trans)
{
Ptr<MgPropertyCollection> ret;
MG_FEATURE_SERVICE_TRY()
CHECK_FEATURE_SOURCE_ARGUMENT(resource, L"MgdUpdateFeaturesCommand::ExecuteInsert");
CHECKARGUMENTNULL(batchPropertyValues, L"MgdUpdateFeaturesCommand::ExecuteInsert");
if (className.empty())
throw new MgNullArgumentException(L"MgdUpdateFeaturesCommand::ExecuteInsert", __LINE__, __WFILE__, NULL, L"", NULL);
ret = new MgPropertyCollection();
Ptr<MgdFeatureConnection> connWrap;
FdoPtr<FdoIConnection> conn;
FdoPtr<FdoITransaction> fdoTrans;
Ptr<MgdTransaction> mgTrans = dynamic_cast<MgdTransaction*>(trans);
if (NULL != mgTrans)
{
SAFE_ADDREF(mgTrans.p);
Ptr<MgResourceIdentifier> origFeatureSource = mgTrans->GetFeatureSource();
//Check that the transaction originates from the same feature source
if (origFeatureSource->ToString() != resource->ToString())
throw new MgInvalidArgumentException(L"MgdUpdateFeaturesCommand::ExecuteInsert", __LINE__, __WFILE__, NULL, L"", NULL);
connWrap = mgTrans->GetConnection(); //Connection is already open
fdoTrans = mgTrans->GetFdoTransaction();
}
else
{
connWrap = new MgdFeatureConnection(resource);
}
conn = connWrap->GetConnection();
FdoPtr<FdoIInsert> insert = (FdoIInsert*)conn->CreateCommand(FdoCommandType_Insert);
insert->SetFeatureClassName(className.c_str());
FdoPtr<FdoPropertyValueCollection> propVals = insert->GetPropertyValues();
if (NULL != fdoTrans.p)
insert->SetTransaction(fdoTrans);
//TODO: Support batch parameters, the main beneficiary of this API. Even then,
//the value flipping approach employed here has performance benefits for certain
//providers, like SQLite
for (INT32 i = 0; i < batchPropertyValues->GetCount(); i++)
{
Ptr<MgPropertyCollection> propertyValues = batchPropertyValues->GetItem(i);
//First feature, set up the FDO property value collection
if (i == 0)
{
for (INT32 i = 0; i < propertyValues->GetCount(); i++)
{
Ptr<MgProperty> mgp = propertyValues->GetItem(i);
FdoPtr<FdoPropertyValue> pv = MgdFeatureUtil::MgPropertyToFdoProperty(mgp);
propVals->Add(pv);
}
}
else //Feature after the first
{
//Set all to null
for (INT32 i = 0; i < propVals->GetCount(); i++)
{
FdoPtr<FdoPropertyValue> fp = propVals->GetItem(i);
FdoPtr<FdoValueExpression> expr = fp->GetValue();
FdoDataValue* fdv = dynamic_cast<FdoDataValue*>(expr.p);
FdoGeometryValue* fgv = dynamic_cast<FdoGeometryValue*>(expr.p);
if (fdv)
{
fdv->SetNull();
}
else if (fgv)
{
fgv->SetNullValue();
}
}
//Now set the appropriate values. MgdFeatureUtil does the work
for (INT32 i = 0; i < propertyValues->GetCount(); i++)
{
Ptr<MgNullableProperty> mgp = (MgNullableProperty*)propertyValues->GetItem(i);
if (!mgp->IsNull())
{
FdoPtr<FdoPropertyValue> fp = propVals->GetItem(mgp->GetName().c_str());
MgdFeatureUtil::UpdateFdoPropertyValue(fp, mgp);
}
}
}
STRING sIndex;
MgUtil::Int32ToString(i, sIndex);
//Insert and stash the result in the property collection
FdoPtr<FdoIFeatureReader> insertRes = insert->Execute();
Ptr<MgFeatureReader> fr = new MgdFeatureReader(connWrap, insertRes);
Ptr<MgFeatureProperty> fp = new MgFeatureProperty(sIndex, fr);
ret->Add(fp);
}
MG_FEATURE_SERVICE_CATCH_AND_THROW_WITH_FEATURE_SOURCE(L"MgdUpdateFeaturesCommand::ExecuteInsert", resource)
return ret.Detach();
}
void FdoSpatialContextTest::InsertFeatures( FdoIConnection* connection )
{
FdoPtr<FdoIInsert> insertCommand;
FdoPtr<FdoPropertyValueCollection> propertyValues;
FdoPtr<FdoDataValue> dataValue;
FdoPtr<FdoPropertyValue> propertyValue;
FdoPtr<FdoIFeatureReader> reader;
insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
insertCommand->SetFeatureClassName(L"ClassB1");
propertyValues = insertCommand->GetPropertyValues();
propertyValue;
double coordsBuffer[4];
int segCount = 2;
FdoPtr<FdoFgfGeometryFactory> gf = FdoFgfGeometryFactory::GetInstance();
coordsBuffer[0] = 2.1;
coordsBuffer[1] = 3.1;
coordsBuffer[2] = 4.1;
coordsBuffer[3] = 5.1;
FdoPtr<FdoILineString> line1 = gf->CreateLineString(FdoDimensionality_XY, segCount*2, coordsBuffer);
FdoPtr<FdoByteArray> byteArray = gf->GetFgf(line1);
FdoPtr<FdoGeometryValue> geometryValue = FdoGeometryValue::Create(byteArray);
propertyValue = FdoPropertyValue::Create(L"Geometry1", geometryValue);
propertyValues->Add(propertyValue);
coordsBuffer[0] += 0.1;
coordsBuffer[1] += 0.1;
coordsBuffer[2] += 0.1;
coordsBuffer[3] += 0.1;
line1 = gf->CreateLineString(FdoDimensionality_XY, segCount*2, coordsBuffer);
byteArray = gf->GetFgf(line1);
geometryValue = FdoGeometryValue::Create(byteArray);
propertyValue = FdoPropertyValue::Create(L"Geometry2", geometryValue);
propertyValues->Add(propertyValue);
coordsBuffer[0] += 0.1;
coordsBuffer[1] += 0.1;
coordsBuffer[2] += 0.1;
coordsBuffer[3] += 0.1;
line1 = gf->CreateLineString(FdoDimensionality_XY, segCount*2, coordsBuffer);
byteArray = gf->GetFgf(line1);
geometryValue = FdoGeometryValue::Create(byteArray);
propertyValue = FdoPropertyValue::Create(L"Geometry3", geometryValue);
propertyValues->Add(propertyValue);
coordsBuffer[0] += 0.1;
coordsBuffer[1] += 0.1;
coordsBuffer[2] += 0.1;
coordsBuffer[3] += 0.1;
line1 = gf->CreateLineString(FdoDimensionality_XY, segCount*2, coordsBuffer);
byteArray = gf->GetFgf(line1);
geometryValue = FdoGeometryValue::Create(byteArray);
propertyValue = FdoPropertyValue::Create(L"Geometry4", geometryValue);
propertyValues->Add(propertyValue);
coordsBuffer[0] += 0.1;
coordsBuffer[1] += 0.1;
coordsBuffer[2] += 0.1;
coordsBuffer[3] += 0.1;
line1 = gf->CreateLineString(FdoDimensionality_XY, segCount*2, coordsBuffer);
byteArray = gf->GetFgf(line1);
geometryValue = FdoGeometryValue::Create(byteArray);
propertyValue = FdoPropertyValue::Create(L"Geometry5", geometryValue);
propertyValues->Add(propertyValue);
reader = insertCommand->Execute();
}
void FdoSchemaRollbackTest::CreateAcadSchema( FdoIConnection* connection )
{
FdoPtr<FdoIApplySchema> pCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
FdoFeatureSchemasP pSchemas = FdoFeatureSchemaCollection::Create(NULL);
FdoPtr<FdoFeatureSchema> pSchema = FdoFeatureSchema::Create( L"Acad", L"AutoCAD schema" );
pSchemas->Add( pSchema );
// Id'less class for Object Properties only
FdoPtr<FdoClass> pXData = FdoClass::Create( L"AcXData", L"Xdata" );
pXData->SetIsAbstract(false);
FdoPtr<FdoDataPropertyDefinition> pXDataSeq = FdoDataPropertyDefinition::Create( L"Seq", L"seq" );
pXDataSeq->SetDataType( FdoDataType_Int32 );
pXDataSeq->SetNullable(false);
FdoPropertiesP(pXData->GetProperties())->Add( pXDataSeq );
FdoPtr<FdoDataPropertyDefinition> pProp = FdoDataPropertyDefinition::Create( L"Datavalue", L"datavalue" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(4000);
pProp->SetNullable(false);
FdoPropertiesP(pXData->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pXData );
// More Id'less classes used to test unique table name generation
FdoPtr<FdoClass> pCoordVal = FdoClass::Create( L"AcDbVertexCoordinateValue", L"" );
pCoordVal->SetIsAbstract(false);
FdoPtr<FdoDataPropertyDefinition> pCoordValSeq = FdoDataPropertyDefinition::Create( L"Seq", L"seq" );
pCoordValSeq->SetDataType( FdoDataType_Int32 );
pCoordValSeq->SetNullable(false);
FdoPropertiesP(pCoordVal->GetProperties())->Add( pCoordValSeq );
pProp = FdoDataPropertyDefinition::Create( L"Value", L"" );
pProp->SetDataType( FdoDataType_Double );
pProp->SetNullable(false);
FdoPropertiesP(pCoordVal->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pCoordVal );
FdoPtr<FdoClass> pVertex = FdoClass::Create( L"AcDbVertexData", L"" );
pVertex->SetIsAbstract(false);
FdoPtr<FdoDataPropertyDefinition> pVertexSeq = FdoDataPropertyDefinition::Create( L"Seq", L"seq" );
pVertexSeq->SetDataType( FdoDataType_Int32 );
pVertexSeq->SetNullable(false);
FdoPropertiesP(pVertex->GetProperties())->Add( pVertexSeq );
FdoPtr<FdoObjectPropertyDefinition> pObjProp = FdoObjectPropertyDefinition::Create( L"point", L"" );
pObjProp->SetClass( pCoordVal );
pObjProp->SetIdentityProperty( pCoordValSeq );
pObjProp->SetObjectType( FdoObjectType_Collection );
FdoPropertiesP(pVertex->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pVertex );
// A non-abstract base class
FdoPtr<FdoFeatureClass> pEntClass = FdoFeatureClass::Create( L"AcDbEntity", L"AutoCAD entity base class" );
pEntClass->SetIsAbstract(false);
pProp = FdoDataPropertyDefinition::Create( L"FeatId", L"id" );
pProp->SetDataType( FdoDataType_Int64 );
pProp->SetNullable(false);
pProp->SetIsAutoGenerated(true);
FdoPropertiesP(pEntClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pEntClass->GetIdentityProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Layer", L"Acad layer" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(10);
pProp->SetNullable(true);
FdoPropertiesP(pEntClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"ColourIndex", L"Acad Colour" );
pProp->SetDataType( FdoDataType_Byte );
pProp->SetNullable(false);
FdoPropertiesP(pEntClass->GetProperties())->Add( pProp );
pObjProp = FdoObjectPropertyDefinition::Create( L"xdata", L"xdata" );
pObjProp->SetClass( pXData );
pObjProp->SetIdentityProperty( pXDataSeq );
pObjProp->SetObjectType( FdoObjectType_OrderedCollection );
pObjProp->SetOrderType( FdoOrderType_Ascending );
FdoPropertiesP(pEntClass->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pEntClass );
FdoPtr<FdoClass> pEntRefClass = FdoClass::Create( L"Entity", L"Embedded entity base class" );
pEntRefClass->SetIsAbstract(false);
pProp = FdoDataPropertyDefinition::Create( L"FeatId", L"id" );
pProp->SetDataType( FdoDataType_Int64 );
pProp->SetNullable(false);
FdoPropertiesP(pEntRefClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pEntRefClass->GetIdentityProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Layer", L"Acad layer" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(10);
pProp->SetNullable(true);
FdoPropertiesP(pEntRefClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"ColourIndex", L"Acad Colour" );
pProp->SetDataType( FdoDataType_Byte );
pProp->SetNullable(true);
FdoPropertiesP(pEntRefClass->GetProperties())->Add( pProp );
pObjProp = FdoObjectPropertyDefinition::Create( L"xdata", L"xdata" );
pObjProp->SetClass( pXData );
pObjProp->SetIdentityProperty( pXDataSeq );
pObjProp->SetObjectType( FdoObjectType_OrderedCollection );
pObjProp->SetOrderType( FdoOrderType_Ascending );
FdoPropertiesP(pEntRefClass->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pEntRefClass );
// A sub-class to test Object and Data property inheritance.
FdoPtr<FdoFeatureClass> pPlineClass = FdoFeatureClass::Create( L"AcDb3dPolyline", L"AutoCAD 3d polyline" );
pPlineClass->SetIsAbstract(false);
pPlineClass->SetBaseClass( pEntClass );
FdoClassesP(pSchema->GetClasses())->Add( pPlineClass );
pProp = FdoDataPropertyDefinition::Create( L"Width", L"line width" );
pProp->SetDataType( FdoDataType_Double );
pProp->SetPrecision(10);
pProp->SetScale(5);
pProp->SetNullable(false);
FdoPropertiesP(pPlineClass->GetProperties())->Add( pProp );
pCmd->SetFeatureSchema( pSchema );
pCmd->Execute();
pProp = FdoDataPropertyDefinition::Create( L"Closed", L"is first and last points the same" );
pProp->SetDataType( FdoDataType_Boolean );
pProp->SetNullable(!mCanAddNotNullCol);
FdoPropertiesP(pPlineClass->GetProperties())->Add( pProp );
pObjProp = FdoObjectPropertyDefinition::Create( L"vertices", L"" );
pObjProp->SetClass( pVertex );
pObjProp->SetIdentityProperty( pVertexSeq );
pObjProp->SetObjectType( FdoObjectType_Collection );
FdoPropertiesP(pPlineClass->GetProperties())->Add( pObjProp );
FdoPtr<FdoClass> pPlineRefClass = FdoClass::Create( L"Polyline", L"Embedded 3d polyline" );
pPlineRefClass->SetIsAbstract(false);
pPlineRefClass->SetBaseClass( pEntRefClass );
FdoClassesP(pSchema->GetClasses())->Add( pPlineRefClass );
pProp = FdoDataPropertyDefinition::Create( L"Width", L"line width" );
pProp->SetDataType( FdoDataType_Double );
pProp->SetPrecision(10);
pProp->SetScale(5);
pProp->SetNullable(false);
FdoPropertiesP(pPlineRefClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Closed", L"is first and last points the same" );
pProp->SetDataType( FdoDataType_Boolean );
pProp->SetNullable(false);
FdoPropertiesP(pPlineRefClass->GetProperties())->Add( pProp );
pObjProp = FdoObjectPropertyDefinition::Create( L"vertices", L"" );
pObjProp->SetClass( pVertex );
pObjProp->SetIdentityProperty( pVertexSeq );
pObjProp->SetObjectType( FdoObjectType_Collection );
FdoPropertiesP(pPlineRefClass->GetProperties())->Add( pObjProp );
// The following tests object property nesting to 3 levels.
FdoPtr<FdoFeatureClass> pHatchClass = FdoFeatureClass::Create( L"AcDbHatch", L"AutoCAD hatched polygon" );
pHatchClass->SetIsAbstract(false);
pHatchClass->SetBaseClass( pEntClass );
pObjProp = FdoObjectPropertyDefinition::Create( L"edges", L"" );
pObjProp->SetClass( pPlineRefClass );
pObjProp->SetObjectType( FdoObjectType_Collection );
FdoPropertiesP(pHatchClass->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pHatchClass );
pCmd->SetFeatureSchema( pSchema );
pCmd->Execute();
}
void SuperMapSelectTest::select_sdb_date()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
if(Select)
{
Select->SetFeatureClassName(L"面");
FdoString *strFilter = L"TestDate <= TIMESTAMP '2007-12-12 00:00:00'";
Select->SetFilter( strFilter );
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
FdoDateTime Date;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"TestDate"))
{
Date = ret->GetDateTime (L"TestDate");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_Polygon == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出面数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
}
}
void FdoSchemaRollbackTest::ModElectricSchema( FdoIConnection* connection )
{
/* Test modifying an existing schema */
FdoPtr<FdoIDescribeSchema> pDescCmd = (FdoIDescribeSchema*) connection->CreateCommand(FdoCommandType_DescribeSchema);
pDescCmd->SetSchemaName( L"Electric'l" );
FdoFeatureSchemasP pSchemas = pDescCmd->Execute();
FdoPtr<FdoIApplySchema> pCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
FdoPtr<FdoFeatureSchema> pSchema = pSchemas->GetItem( L"Electric'l" );
FdoPtr<FdoFeatureClass> pClass = (FdoFeatureClass*) (FdoClassesP(pSchema->GetClasses())->GetItem(L"Transformer"));
pClass->Delete();
// Add a new non-inherited class that will later be removed.
pClass = FdoFeatureClass::Create( L"Pole", L"" );
pClass->SetIsAbstract(false);
FdoPtr<FdoDataPropertyDefinition> pProp = FdoDataPropertyDefinition::Create( L"FeatureId", L"" );
pProp->SetDataType( FdoDataType_Int64 );
pProp->SetIsAutoGenerated(true);
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pClass->GetIdentityProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Height", L"" );
pProp->SetDataType( FdoDataType_Double );
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pClass );
/* The following 3 classes tests adding nested object properties to an FdoClass,
* instead of an FdoFeatureClass.
*/
// class for nested object property
FdoPtr<FdoClass> pStClass = FdoClass::Create( L"Street", L"" );
pStClass->SetIsAbstract(false);
pProp = FdoDataPropertyDefinition::Create( L"Name", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength( 30 );
pProp->SetNullable(false);
FdoPropertiesP(pStClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Type", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength( 30 );
pProp->SetNullable(false);
FdoPropertiesP(pStClass->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pStClass );
// Class for top object property ( includes nested property )
FdoPtr<FdoClass> pAddrClass = FdoClass::Create( L"'Address", L"" );
pAddrClass->SetIsAbstract(false);
pProp = FdoDataPropertyDefinition::Create( L"Number", L"" );
pProp->SetDataType( FdoDataType_Int32 );
pProp->SetNullable(false);
FdoPropertiesP(pAddrClass->GetProperties())->Add( pProp );
FdoPtr<FdoObjectPropertyDefinition> pObjProp = FdoObjectPropertyDefinition::Create( L"street", L"" );
pObjProp->SetClass( pStClass );
pObjProp->SetObjectType( FdoObjectType_Value );
FdoPropertiesP(pAddrClass->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pAddrClass );
// Class that contains top object property
FdoPtr<FdoClass> pEmpClass = FdoClass::Create( L"Employee", L"" );
pEmpClass->SetIsAbstract(false);
pProp = FdoDataPropertyDefinition::Create( L"First Name", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength( 30 );
pProp->SetNullable(false);
FdoPropertiesP(pEmpClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pEmpClass->GetIdentityProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Last Name", L"" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength( 30 );
pProp->SetNullable(false);
FdoPropertiesP(pEmpClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pEmpClass->GetIdentityProperties())->Add( pProp );
pObjProp = FdoObjectPropertyDefinition::Create( L"home' address", L"" );
pObjProp->SetClass( pAddrClass );
pObjProp->SetObjectType( FdoObjectType_Value );
FdoPropertiesP(pEmpClass->GetProperties())->Add( pObjProp );
FdoClassesP(pSchema->GetClasses())->Add( pEmpClass );
pCmd->SetFeatureSchema( pSchema );
pCmd->Execute();
}
void SuperMapSelectTest::select_line()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
Select->SetFeatureClassName(L"线");
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
double Length;
int ToPoError;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"SmLength"))
{
Length = ret->GetDouble (L"SmLength");
}
if(!ret->IsNull(L"SmTopoError"))
{
ToPoError = ret->GetInt32 (L"SmTopoError");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_MultiLineString == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出点数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
}
MgSpatialContextReader* MgServerGetSpatialContexts::GetSpatialContexts(MgResourceIdentifier* resId)
{
Ptr<MgSpatialContextReader> mgSpatialContextReader;
MG_FEATURE_SERVICE_TRY()
mgSpatialContextReader = m_featureServiceCache->GetSpatialContextReader(resId);
if (NULL == mgSpatialContextReader.p)
{
// Connect to provider
Ptr<MgServerFeatureConnection> msfc = new MgServerFeatureConnection(resId);
// Connection must be open to retrieve a list of available contexts.
if ((NULL != msfc.p) && ( msfc->IsConnectionOpen() ))
{
// The reference to the FDO connection from the MgServerFeatureConnection object must be cleaned up before the parent object
// otherwise it leaves the FDO connection marked as still in use.
FdoPtr<FdoIConnection> fdoConn = msfc->GetConnection();
m_providerName = msfc->GetProviderName();
Ptr<MgSpatialContextCacheItem> cacheItem = MgCacheManager::GetInstance()->GetSpatialContextCacheItem(resId);
MgSpatialContextInfo* spatialContextInfo = cacheItem->Get();
// Check whether command is supported by provider
if (!msfc->SupportsCommand((INT32)FdoCommandType_GetSpatialContexts))
{
// TODO: specify which argument and message, once we have the mechanism
STRING message = MgServerFeatureUtil::GetMessage(L"MgCommandNotSupported");
throw new MgInvalidOperationException(L"MgServerGetSpatialContexts.GetSpatialContexts", __LINE__, __WFILE__, NULL, L"", NULL);
}
FdoPtr<FdoIGetSpatialContexts> fdoCommand = (FdoIGetSpatialContexts*)fdoConn->CreateCommand(FdoCommandType_GetSpatialContexts);
CHECKNULL((FdoIGetSpatialContexts*)fdoCommand, L"MgServerGetSpatialContexts.GetSpatialContexts");
// Execute the command
FdoPtr<FdoISpatialContextReader> spatialReader = fdoCommand->Execute();
CHECKNULL((FdoISpatialContextReader*)spatialReader, L"MgServerGetSpatialContexts.GetSpatialContexts");
mgSpatialContextReader = new MgSpatialContextReader();
while (spatialReader->ReadNext())
{
// Set providername for which spatial reader is executed
mgSpatialContextReader->SetProviderName(m_providerName);
Ptr<MgSpatialContextData> spatialData = GetSpatialContextData(spatialReader, spatialContextInfo);
CHECKNULL((MgSpatialContextData*)spatialData, L"MgServerGetSpatialContexts.GetSpatialContexts");
// Add spatial data to the spatialcontext reader
mgSpatialContextReader->AddSpatialData(spatialData);
}
m_featureServiceCache->SetSpatialContextReader(resId, mgSpatialContextReader.p);
}
else
{
throw new MgConnectionFailedException(L"MgServerGetSpatialContexts.GetSpatialContexts()", __LINE__, __WFILE__, NULL, L"", NULL);
}
}
else
{
MgCacheManager::GetInstance()->CheckPermission(resId, MgResourcePermission::ReadOnly);
}
MG_FEATURE_SERVICE_CHECK_CONNECTION_CATCH_AND_THROW(resId, L"MgServerGetSpatialContexts.GetSpatialContexts")
return mgSpatialContextReader.Detach();
}
void MySqlFdoInsertTest::insertBoundaryUnsigned()
{
StaticConnection* conn = new MySqlStaticConnection();
try {
UnitTestUtil::SetProvider( conn->GetServiceName() );
conn->connect();
FdoSchemaManagerP mgr = conn->CreateSchemaManager();
FdoSmPhMgrP phMgr = mgr->GetPhysicalSchema();
FdoStringP datastore = phMgr->GetDcOwnerName(
UnitTestUtil::GetEnviron("datastore", UNSIGNED_SUFFIX)
);
FdoSmPhDatabaseP database = phMgr->GetDatabase();
FdoSmPhOwnerP owner = phMgr->FindOwner( datastore, L"", false );
if ( owner ) {
owner->SetElementState( FdoSchemaElementState_Deleted );
owner->Commit();
}
owner = database->CreateOwner(
datastore,
false
);
owner->SetPassword( L"test" );
FdoStringP tableName = L"unsigned_test";
FdoSmPhTableP table = owner->CreateTable( tableName );
table->SetPkeyName( tableName + L"_key" );
FdoSmPhColumnP column = table->CreateColumnInt32(
L"id",
false
);
table->AddPkeyCol( column->GetName() );
column = table->CreateColumnUnknown(
L"uint_column",
L"int unsigned",
false,
0,
0
);
owner->Commit();
phMgr = NULL;
mgr = NULL;
conn->disconnect();
delete conn;
conn = NULL;
FdoPtr<FdoIConnection> connection = UnitTestUtil::GetConnection(UNSIGNED_SUFFIX, false);
FdoPtr<FdoITransaction> featureTransaction = connection->BeginTransaction();
FdoPtr<FdoIInsert> insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
insertCommand->SetFeatureClassName(tableName);
FdoPtr<FdoPropertyValueCollection> propertyValues = insertCommand->GetPropertyValues();
FdoPtr<FdoDataValue> dataValue;
dataValue = FdoDataValue::Create(L"1");
FdoPtr<FdoPropertyValue> propertyValue = AddNewProperty( propertyValues, L"id");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create(L"0");
propertyValue = AddNewProperty( propertyValues, L"uint_column");
propertyValue->SetValue(dataValue);
FdoPtr<FdoIFeatureReader> reader = insertCommand->Execute();
dataValue = FdoDataValue::Create(L"2");
propertyValue = AddNewProperty( propertyValues, L"id");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create(L"4294967295");
propertyValue = AddNewProperty( propertyValues, L"uint_column");
propertyValue->SetValue(dataValue);
reader = insertCommand->Execute();
featureTransaction->Commit();
// check
FdoPtr<FdoISelect> selectCmd = (FdoISelect *) connection->CreateCommand(FdoCommandType_Select);
selectCmd->SetFeatureClassName(tableName);
FdoPtr<FdoIFeatureReader> featureReader = selectCmd->Execute();
FdoInt32 rowCount = 0;
while ( featureReader->ReadNext() ) {
rowCount++;
switch ( featureReader->GetInt32(L"id") ) {
case 1:
CPPUNIT_ASSERT ( featureReader->GetInt64(L"uint_column") == 0 );
break;
case 2:
CPPUNIT_ASSERT ( featureReader->GetInt64(L"uint_column") == 4294967295LL);
break;
}
}
CPPUNIT_ASSERT( rowCount == 2 );
}
catch (FdoCommandException *ex)
{
if (conn)
{
conn->disconnect();
delete conn;
}
UnitTestUtil::FailOnException(ex);
}
catch (FdoException *ex)
{
if (conn)
{
conn->disconnect();
delete conn;
}
UnitTestUtil::FailOnException(ex);
}
}
/* Test basic update operation. */
void BasicUpdateTests::simple_update ()
{
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcov());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassSimple(), ArcSDETestConfig::ClassNameTestClassSimple(), true);
// insert a feature
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassSimple());
FdoPtr<FdoPropertyValueCollection> values = insert->GetPropertyValues ();
FdoPtr<FdoValueExpression> expression = (FdoValueExpression*)FdoExpression::Parse (Data[0]->mPropertyData[0]);
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create (Data[0]->mPropertyName, expression);
values->Add (value);
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5108.8 5104.7, 5109 5104, 5109 5105, 5108.8 5104.7))')");
value = FdoPropertyValue::Create ((FdoString*)GetGeomPropName(), expression);
values->Add (value);
FdoPtr<FdoIFeatureReader> reader = insert->Execute ();
int id;
while (reader->ReadNext ())
id = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
// update it
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassSimple());
FdoPtr<FdoPropertyValueCollection> propertyValues = update->GetPropertyValues();
wchar_t filter[1024];
FdoCommonOSUtil::swprintf(filter, ELEMENTS(filter), L"%ls = %d", (FdoString*)GetIdPropName(), id);
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
values = update->GetPropertyValues ();
value = FdoPropertyValue::Create ();
value->SetName (Data[0]->mPropertyName);
//FdoPtr<FdoStringValue> _string = static_cast<FdoStringValue*>(value->GetValue ());
//_string->SetNull ();
value->SetValue (L"'All mimsy were the borogoves'");
values->Add (value);
if (1 != update->Execute ())
CPPUNIT_FAIL ("update execute failed");
// check by doing a select
FdoPtr<FdoISelect> select = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
select->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassSimple());
reader = select->Execute ();
while (reader->ReadNext ())
{
CPPUNIT_ASSERT_MESSAGE ("incorrect value", 0 == wcscmp (L"All mimsy were the borogoves", reader->GetString (Data[0]->mPropertyName)));
// check geometry was not affected
FdoPtr<FdoGeometryValue> geometry = (FdoGeometryValue*)FDO_SAFE_ADDREF(expression.p);
FdoPtr<FdoByteArray> fetched = reader->GetGeometry ((FdoString*)GetGeomPropName());
FdoString* geometryText = geometry->ToString();
FdoPtr<FdoGeometryValue> fetchedGeom = FdoGeometryValue::Create (fetched);
FdoString* fetchedText = fetchedGeom->ToString ();
CPPUNIT_ASSERT_MESSAGE ("incorrect geometry value", 0==wcscmp(geometryText, fetchedText));
}
reader->Close();
// Clean up after test:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassSimple(), ArcSDETestConfig::ClassNameTestClassSimple(), true);
}
catch (FdoException* ge)
{
fail (ge);
}
}
void FdoSchemaRollbackTest::CreateElectricSchema( FdoIConnection* connection )
{
FdoPtr<FdoIDescribeSchema> pDescCmd = (FdoIDescribeSchema*) connection->CreateCommand(FdoCommandType_DescribeSchema);
pDescCmd->SetSchemaName( L"Acad" );
FdoPtr<FdoFeatureSchemaCollection> pAcadSchema = pDescCmd->Execute();
FdoPtr<FdoClassDefinition> pEntClass = FdoClassesP(FdoFeatureSchemaP(pAcadSchema->GetItem( L"Acad" ))->GetClasses())->GetItem( L"Entity" );
FdoPtr<FdoIApplySchema> pCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
/* A schema with dictionary */
FdoPtr<FdoFeatureSchema> pSchema = FdoFeatureSchema::Create( L"Electric'l", L"Electrical '' schema'" );
pAcadSchema->Add( pSchema );
FdoSADP(pSchema->GetAttributes())->Add( L"'Author", L"Thomas O'Edison" );
/* An abstract base class */
FdoPtr<FdoFeatureClass> pDevClass = FdoFeatureClass::Create( L"ElectricDevice", L"electic base class" );
pDevClass->SetIsAbstract(true);
FdoPtr<FdoDataPropertyDefinition> pProp = FdoDataPropertyDefinition::Create( L"FeatId", L"id" );
pProp->SetDataType( FdoDataType_Int64 );
pProp->SetNullable(false);
pProp->SetIsAutoGenerated(true);
FdoPropertiesP(pDevClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pDevClass->GetIdentityProperties())->Add( pProp );
// Test nested object properties (ElectricDevice.graphic.xdata) where graphic's class has an id.
FdoPtr<FdoObjectPropertyDefinition> pObjProp = FdoObjectPropertyDefinition::Create( L"graphic", L"Acad entity" );
pObjProp->SetObjectType( FdoObjectType_Value );
pObjProp->SetClass( pEntClass );
FdoPropertiesP(pDevClass->GetProperties())->Add( pObjProp );
// Test geometry property
FdoPtr<FdoGeometricPropertyDefinition> pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry", L"location and shape" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
FdoPropertiesP(pDevClass->GetProperties())->Add( pGeomProp );
pDevClass->SetGeometryProperty( pGeomProp );
FdoClassesP(pSchema->GetClasses())->Add( pDevClass );
/* Subclass with dictionary */
FdoPtr<FdoFeatureClass> pClass = FdoFeatureClass::Create( L"Transformer", L"" );
pClass->SetIsAbstract(false);
pClass->SetBaseClass( pDevClass );
FdoSADP(pClass->GetAttributes())->Add( L"Rules' DLL", L"transformer.dll" );
FdoSADP(pClass->GetAttributes())->Add( L"Entrypoint", L"start_transformer" );
// Add data properties of various types
pProp = FdoDataPropertyDefinition::Create( L"Voltage", L"voltage" );
FdoSADP(pProp->GetAttributes())->Add( L"Calculable", L"yes" );
pProp->SetDataType( FdoDataType_Decimal );
pProp->SetPrecision(10);
pProp->SetScale(2);
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Phase", L"A, B or C" );
pProp->SetDataType( FdoDataType_String );
pProp->SetLength(1);
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"InstallDate", L"" );
pProp->SetDataType( FdoDataType_DateTime );
pProp->SetNullable(true);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"LastInspectDate", L"" );
pProp->SetDataType( FdoDataType_DateTime );
pProp->SetNullable(true);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"LastRepairDate", L"" );
pProp->SetDataType( FdoDataType_DateTime );
pProp->SetNullable(true);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"PartNum", L"" );
pProp->SetDataType( FdoDataType_Int16 );
pProp->SetNullable(true);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
pProp = FdoDataPropertyDefinition::Create( L"Volume", L"" );
pProp->SetDataType( FdoDataType_Single );
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pClass );
pClass = FdoFeatureClass::Create( L"Conductor", L"" );
pClass->SetIsAbstract(false);
pClass->SetBaseClass( pDevClass );
pProp = FdoDataPropertyDefinition::Create( L"underground", L"" );
pProp->SetDataType( FdoDataType_Boolean );
pProp->SetNullable(false);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
FdoClassesP(pSchema->GetClasses())->Add( pClass );
pCmd->SetFeatureSchema( pSchema );
pCmd->Execute();
}
void FdoSpatialContextTest::CreateSchema( FdoIConnection* connection, bool hasMetaSchema )
{
FdoPtr<FdoFeatureSchema> schema;
if ( hasMetaSchema ) {
/* A schema with dictionary */
schema = FdoFeatureSchema::Create( L"ScTest", L"" );
}
else {
FdoPtr<FdoIDescribeSchema> cmd = (FdoIDescribeSchema*) connection->CreateCommand(FdoCommandType_DescribeSchema);
FdoFeatureSchemasP schemas = cmd->Execute();
CPPUNIT_ASSERT( schemas->GetCount() > 0 );
schema = schemas->FindItem(L"dbo");
if ( !schema )
schema = schemas->GetItem(0);
}
FdoPtr<FdoIApplySchema> pCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
/* An abstract base class */
FdoPtr<FdoFeatureClass> pClass = FdoFeatureClass::Create( L"ClassB1", L"" );
FdoClassesP(schema->GetClasses())->Add( pClass );
FdoPtr<FdoDataPropertyDefinition> pProp = FdoDataPropertyDefinition::Create( L"Prop1", L"" );
pProp->SetDataType( FdoDataType_Int64 );
pProp->SetNullable(false);
pProp->SetIsAutoGenerated(true);
FdoPropertiesP(pClass->GetProperties())->Add( pProp );
FdoDataPropertiesP(pClass->GetIdentityProperties())->Add( pProp );
// Test geometry property
FdoPtr<FdoGeometricPropertyDefinition> pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry1", L"" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
pGeomProp->SetSpatialContextAssociation(L"Bermuda");
FdoPropertiesP(pClass->GetProperties())->Add( pGeomProp );
pClass->SetGeometryProperty( pGeomProp );
pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry2", L"" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
pGeomProp->SetSpatialContextAssociation(L"Rectangular");
FdoPropertiesP(pClass->GetProperties())->Add( pGeomProp );
pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry3", L"" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
pGeomProp->SetSpatialContextAssociation(L"South");
FdoPropertiesP(pClass->GetProperties())->Add( pGeomProp );
pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry4", L"" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
pGeomProp->SetSpatialContextAssociation(L"Bermuda Duplicate");
FdoPropertiesP(pClass->GetProperties())->Add( pGeomProp );
pGeomProp = FdoGeometricPropertyDefinition::Create( L"Geometry5", L"" );
pGeomProp->SetGeometryTypes( FdoGeometricType_Point | FdoGeometricType_Curve );
pGeomProp->SetSpatialContextAssociation(L"sc_1");
FdoPropertiesP(pClass->GetProperties())->Add( pGeomProp );
pCmd->SetFeatureSchema( schema );
pCmd->Execute();
}
void SuperMapSelectTest::select_region()
{
CPPUNIT_ASSERT_MESSAGE("FDO连接未打开!", m_connection != NULL);
CPPUNIT_ASSERT_MESSAGE("FDO连接引用次数不为1!", m_connection->GetRefCount() == 1);
FdoPtr<FdoISelect> Select;
Select = (FdoISelect *)m_connection->CreateCommand(FdoCommandType_Select);
Select->SetFeatureClassName(L"面");
FdoPtr<FdoIFeatureReader> ret;
try
{
ret = Select->Execute();
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
CPPUNIT_ASSERT_MESSAGE("返回的要素集合为空!", ret != NULL);
int count = 0;
int SmID;
int UserID;
double SmArea;
double SmPerimeter;
bool TestBoolen;
short TestShort;
float TestFloat;
FdoString *str;
FdoDateTime date;
int length;
FdoPtr<FdoByteArray> geometry;
try
{
while (ret->ReadNext ())
{
count++;
if(!ret->IsNull(L"SmID"))
{
SmID = ret->GetInt32 (L"SmID");
}
if(!ret->IsNull(L"SmUserID"))
{
UserID = ret->GetInt32 (L"SmUserID");
}
if(!ret->IsNull(L"SmArea"))
{
SmArea = ret->GetDouble (L"SmArea");
}
if(!ret->IsNull(L"SmPerimeter"))
{
SmPerimeter = ret->GetDouble (L"SmPerimeter");
}
if(!ret->IsNull(L"TestBoolen"))
{
TestBoolen = ret->GetBoolean (L"TestBoolen");
}
if(!ret->IsNull(L"TestShort"))
{
TestShort = ret->GetInt16(L"TestShort");
}
if(!ret->IsNull(L"TestFloat"))
{
TestFloat = ret->GetSingle(L"TestFloat");
}
if(!ret->IsNull(L"TestString"))
{
str = ret->GetString(L"TestString");
}
if(!ret->IsNull(L"TestDate"))
{
date = ret->GetDateTime(L"TestDate");
}
if(!ret->IsNull(L"长度"))
{
length = ret->GetInt32(L"长度");
}
if(!ret->IsNull(L"Geometry"))
{
geometry = ret->GetGeometry (L"Geometry");
}
CPPUNIT_ASSERT_MESSAGE ("几何对象类型不正确", FdoGeometryType_Polygon == *(int*)geometry->GetData());
}
CPPUNIT_ASSERT_MESSAGE ("未查出面数据集中的要素", 0 != count);
}
catch (FdoException* ex)
{
FdoException* nex = ex;
while (nex)
{
AfxMessageBox(ex->GetExceptionMessage());
nex = nex->GetCause();
}
ex->Release();
}
catch(...)
{
CPPUNIT_FAIL("unresolved exception");
}
}
// Imports spatial contexts and feature schemas from XML to datastore.
void FdoImportExportTest::Import(
FdoIConnection* connection,
FdoIoStream* stream,
FdoXmlSpatialContextFlags* flags,
FdoBoolean importSC,
FdoBoolean importSchemas
)
{
FdoPtr<FdoITransaction> featureTransaction;
stream->Reset();
// Import the Spatial Contexts
if ( importSC ) {
FdoXmlSpatialContextSerializer::XmlDeserialize(
connection,
FdoXmlSpatialContextReaderP(
FdoXmlSpatialContextReader::Create(
FdoXmlReaderP(
FdoXmlReader::Create(stream)
),
flags
)
),
flags
);
stream->Reset();
}
// Import the Schema Override sets.
FdoSchemaMappingsP mappings = FdoPhysicalSchemaMappingCollection::Create();
stream->Reset();
mappings->ReadXml( stream );
// Import the Feature Schemas
if ( importSchemas ) {
FdoFeatureSchemasP schemas = FdoFeatureSchemaCollection::Create(NULL);
// Deserialize the feature schemas
stream->Reset();
schemas->ReadXml( stream );
// Add each feature schema to the datastore.
FdoPtr<FdoIApplySchema> applyCmd = (FdoIApplySchema*) connection->CreateCommand(FdoCommandType_ApplySchema);
for ( int idx = 0; idx < schemas->GetCount(); idx++ ) {
FdoFeatureSchemaP schema = schemas->GetItem(idx);
applyCmd->SetFeatureSchema( schema );
FdoPhysicalSchemaMappingP overrides =
(FdoPhysicalSchemaMapping*) mappings->GetItem( connection, schema->GetName() );
if ( overrides )
applyCmd->SetPhysicalMapping( overrides );
applyCmd->Execute();
}
FdoFeatureSchemaP insSchema = schemas->FindItem( L"Schema1" );
if ( insSchema ) {
FdoClassDefinitionP insClass = FdoClassesP(insSchema->GetClasses())->FindItem( L"ClassB1" );
if ( insClass ) {
featureTransaction = connection->BeginTransaction();
FdoPtr<FdoIInsert> insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
insertCommand->SetFeatureClassName(insClass->GetQualifiedName());
AddFeature( insertCommand, 1 );
AddFeature( insertCommand, 2 );
AddFeature( insertCommand, 3 );
featureTransaction->Commit();
}
}
}
}
void RfpTestEcw::testRGB()
{
FdoPtr<FdoIConnection> connection = CreateConnection();
FdoPtr<FdoIoStream> stream = FdoIoFileStream::Create(L"../../TestData/Ecw/Adelaide_sample.xml", L"r");
connection->SetConfiguration(stream);
connection->Open();
FdoICommand* cmd = connection->CreateCommand(FdoCommandType_Select);
FdoPtr<FdoISelect> cmdSelect = dynamic_cast<FdoISelect*>(cmd);
cmdSelect->SetFeatureClassName(L"Photo");
FdoPtr<FdoIFeatureReader> featureReader = cmdSelect->Execute();
CPPUNIT_ASSERT(featureReader->ReadNext());
FdoPtr<FdoIRaster> raster = featureReader->GetRaster(L"Image");
FdoInt32 xSize = raster->GetImageXSize();
FdoInt32 ySize = raster->GetImageYSize();
CPPUNIT_ASSERT(xSize == 2814);
CPPUNIT_ASSERT(ySize == 2187);
FdoPtr<FdoRasterDataModel> dataModel = raster->GetDataModel();
CPPUNIT_ASSERT(dataModel->GetBitsPerPixel() == 32);
CPPUNIT_ASSERT(dataModel->GetDataModelType() == FdoRasterDataModelType_RGBA);
CPPUNIT_ASSERT(dataModel->GetTileSizeX() == raster->GetImageXSize());
CPPUNIT_ASSERT(dataModel->GetTileSizeY() == raster->GetImageYSize());
const FdoInt32 tileSizeX = 1024, tileSizeY = 1024;
dataModel->SetTileSizeX(tileSizeX);
dataModel->SetTileSizeY(tileSizeY);
raster->SetDataModel(dataModel);
FdoPtr<FdoIStreamReaderTmpl<FdoByte> > reader = dynamic_cast<FdoIStreamReaderTmpl<FdoByte>*>(raster->GetStreamReader());
int numTileRows = (2187 - 1) / tileSizeX + 1;
int numTileCols = (2814 - 1) / tileSizeY + 1;
const int bytesTile = tileSizeX * tileSizeY * 4;
FdoByte* buffer = new FdoByte[bytesTile];
for (int i = 0; i < numTileRows; i++)
{
// read the first tile of the tile row
FdoInt32 numRead = reader->ReadNext(buffer, 0, bytesTile);
CPPUNIT_ASSERT(numRead == bytesTile);
// skip the rest tiles
reader->Skip(bytesTile * (numTileCols - 1));
}
// no data
CPPUNIT_ASSERT(reader->ReadNext(buffer, 0, 1) == 0);
delete buffer;
// scale down to 1/4 of original size and read it row by row
raster->SetImageXSize(703);
raster->SetImageYSize(546);
dataModel->SetTileSizeX(raster->GetImageXSize());
dataModel->SetTileSizeY(raster->GetImageYSize());
raster->SetDataModel(dataModel);
reader = dynamic_cast<FdoIStreamReaderTmpl<FdoByte>*>(raster->GetStreamReader());
// iterate all rows
FdoByte buff[2816]; //2816=703*4+4
for (int row = 0; row < 546; row++)
{
FdoInt32 numRead = reader->ReadNext(buff, 0, 2816);
CPPUNIT_ASSERT(numRead == 2816);
}
CPPUNIT_ASSERT(reader->ReadNext(buff, 0, 1) == 0);
connection->Close();
}
