// this test depend on insert_WithIdent which creates the valid schema:
// Always run insert_WithIdent before this test.
void FdoAssociationInsertTest::insert_ManyWithIdent()
{
FdoStringP name1 = L"FirstName";
FdoStringP name2 = L"LastName";
FdoPtr<FdoIConnection> connection = UnitTestUtil::GetConnection(DB_SUFFIX);
FdoPtr<FdoITransaction> featureTransaction = connection->BeginTransaction();
FdoPtr<FdoIInsert>insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
// Add instances of the TestClass
FdoPtr<FdoPropertyValueCollection> propertyValues;
FdoPtr<FdoDataValue>dataValue;
FdoPtr<FdoPropertyValue>propertyValue;
FdoPtr<FdoIFeatureReader> reader;
for(int i=90; i<100; i++ )
{
char id[4];
sprintf(id,"%d",i);
FdoStringP idx(id);
FdoStringP val1 = name1 + idx;
FdoStringP val2 = name2 + idx;
insertCommand->SetFeatureClassName(L"TestClass");
propertyValues = insertCommand->GetPropertyValues();
dataValue = FdoDataValue::Create( i );
propertyValue = AddNewProperty( propertyValues, L"Id");
propertyValue->SetValue(dataValue);
// Add the name one property
dataValue = FdoDataValue::Create( (FdoString*)val1 );
propertyValue = AddNewProperty( propertyValues, L"Name One");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( (FdoString*)val2 );
propertyValue = AddNewProperty( propertyValues, L"Name Two");
propertyValue->SetValue(dataValue);
reader = insertCommand->Execute();
// Add an instance of the TestFeatureClass
insertCommand->SetFeatureClassName(L"TestFeatureClass");
propertyValues = insertCommand->GetPropertyValues();
propertyValues->Clear();
dataValue = FdoDataValue::Create( (FdoString*)val1 );
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.Name One");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( (FdoString*)val2 );
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.Name Two");
propertyValue->SetValue(dataValue);
reader = insertCommand->Execute();
}
featureTransaction->Commit();
}
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" );
}
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;
}
///<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;
}
MgSelectCommand::MgSelectCommand(MgResourceIdentifier* resource)
{
CHECKNULL((MgResourceIdentifier*)resource, L"MgSelectCommand.MgSelectCommand");
// Connect to provider
m_connection = new MgServerFeatureConnection(resource);
if ((NULL != m_connection.p) && ( m_connection->IsConnectionOpen() ))
{
m_providerName = m_connection->GetProviderName();
}
else
{
throw new MgConnectionFailedException(L"MgSelectCommand.MgSelectCommand", __LINE__, __WFILE__, NULL, L"", NULL);
}
// Create FdoISelect command
FdoPtr<FdoIConnection> fdoConn = m_connection->GetConnection();
m_command = (FdoISelect*)fdoConn->CreateCommand(FdoCommandType_Select);
CHECKNULL((FdoISelect*)m_command, L"MgSelectCommand.MgSelectCommand");
}
/// <summary>Executes the select command and returns a reference to an FdoIDataReader.</summary>
/// <returns>Returns the feature reader.</returns>
FdoIDataReader* FdoCommonSelectAggregatesCommand::Execute ()
{
FdoString* class_name;
class_name = FdoPtr<FdoIdentifier> (GetFeatureClassName ())->GetName ();
FdoPtr<FdoIConnection> conn = (FdoIConnection*)GetConnection ();
//we will need a vanilla select command to get the features
//the user would like to work with (given class and FdoFilter)
FdoPtr <FdoISelect> selectCmd = (FdoISelect*)conn->CreateCommand(FdoCommandType_Select);
selectCmd->SetFeatureClassName(class_name);
selectCmd->SetFilter(mFilter);
// Get other relevant info:
FdoPtr<FdoIdentifierCollection> selectedIds = GetPropertyNames();
FdoPtr<FdoClassDefinition> originalClassDef = FdoCommonSchemaUtil::GetLogicalClassDefinition(conn, class_name, NULL);
// Create and return the data reader:
FdoPtr<FdoIDataReader> dataReader = new FdoCommonDataReader(conn, selectCmd, originalClassDef, selectedIds, m_bDistinct, m_OrderingIds, m_eOrderingOption);
return FDO_SAFE_ADDREF(dataReader.p);
}
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();
}
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);
}
}
void FdoAssociationInsertTest::masterTestNoObj( FdoAssociationInsertType type, const wchar_t* name1, const wchar_t* name2, int id, bool assocIsFeat, bool ownerIsFeat, int circularType )
{
try
{
// Setup the schema
if( assocIsFeat && ownerIsFeat )
{
if ( circularType > 0 )
mSchemaUtil->TestCreate_NoIdentAssocFeatClassCirc (circularType);
else
mSchemaUtil->TestCreate_NoIdentAssocFeatClass ();
}
else if( !ownerIsFeat )
{
if ( circularType > 0 )
mSchemaUtil->TestCreate_WithIdentNoFeatClassCirc (circularType);
else
mSchemaUtil->TestCreate_WithIdentNoFeatClass();
}
else
{
if( type == Insert_NoIdentity )
{
if ( circularType > 0 )
mSchemaUtil->TestCreate_NoIdentCirc (circularType);
else
mSchemaUtil->TestCreate_NoIdent();
}
else
{
if ( circularType > 0 )
mSchemaUtil->TestCreate_WithIdentCirc (circularType);
else
mSchemaUtil->TestCreate_WithIdent();
}
}
// Get a connection object
FdoPtr<FdoIConnection> connection = UnitTestUtil::GetConnection(DB_SUFFIX);
FdoPtr<FdoITransaction> featureTransaction = connection->BeginTransaction();
FdoPtr<FdoIInsert>insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
// Add an instance of the TestClass
insertCommand->SetFeatureClassName(L"TestClass");
FdoPtr<FdoPropertyValueCollection> propertyValues = insertCommand->GetPropertyValues();
// Add the id property
FdoPtr<FdoDataValue>dataValue;
FdoPtr<FdoPropertyValue>propertyValue;
if( ! assocIsFeat )
{
dataValue = FdoDataValue::Create( id );
propertyValue = AddNewProperty( propertyValues, L"Id");
propertyValue->SetValue(dataValue);
}
// Add the name one property
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"Name One");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Name Two");
propertyValue->SetValue(dataValue);
FdoPtr<FdoIFeatureReader> reader = insertCommand->Execute();
if( assocIsFeat && ownerIsFeat && reader->ReadNext() )
{
id = (long)reader->GetInt64(L"FeatId");
}
// Add an instance of the TestFeatureClass
insertCommand->SetFeatureClassName(L"TestFeatureClass");
propertyValues = insertCommand->GetPropertyValues();
propertyValues->Clear();
// Initialize the association property
if( !ownerIsFeat )
{
dataValue = FdoDataValue::Create(19);
propertyValue = AddNewProperty( propertyValues, L"Id");
propertyValue->SetValue(dataValue);
}
if( type == Insert_NoIdentity )
{
// Initialize the association property
dataValue = FdoDataValue::Create( id );
if( assocIsFeat )
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.FeatId");
else
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.Id");
propertyValue->SetValue(dataValue);
// Initialize the second association
if ( circularType == 0 )
{
if( assocIsFeat )
propertyValue = AddNewProperty( propertyValues, L"Association Prop2.FeatId");
else
propertyValue = AddNewProperty( propertyValues, L"Association Prop2.Id");
propertyValue->SetValue(dataValue);
}
}
if( type == Insert_WithIdentityParent ||
type == Insert_WithIdentityBothSet ||
type == Insert_NoIdentity ||
type == Insert_WithIdentityError )
{
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"First Name");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Last Name");
propertyValue->SetValue(dataValue);
}
if( type == Insert_WithIdentityAssociated ||
type == Insert_WithIdentityBothSet ||
type == Insert_WithIdentityError )
{
// Add the name one property
if( type == Insert_WithIdentityError )
dataValue = FdoDataValue::Create( L"BOGUS" );
else
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.Name One");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Association Prop1.Name Two");
propertyValue->SetValue(dataValue);
}
reader = insertCommand->Execute();
featureTransaction->Commit();
}
catch(FdoException *exp )
{
if( type != Insert_WithIdentityError )
{
printf("Insert Master Test(NO OBJ) Error: %ls\n", exp->GetExceptionMessage() );
UnitTestUtil::PrintException(exp, UnitTestUtil::GetOutputFileName( L"TestSchema.txt" ) );
exp->Release();
CPPUNIT_FAIL ( "Insert Master Test(NO OBJ) exception" );
}
else
{
printf("Insert Master Test(NO OBJ) Expected Error: %ls\n", exp->GetExceptionMessage() );
exp->Release();
return;
}
}
if( type == Insert_WithIdentityError )
{
printf("Insert Master Test(NO OBJ) SHOULD Fail");
CPPUNIT_FAIL ( "Insert Master Test(NO OBJ) SHOULD Fail" );
}
}
void FdoAssociationInsertTest::masterTestWithObj(FdoAssociationInsertType type, const wchar_t* name1, const wchar_t* name2, int id )
{
try
{
// Get a connection object
FdoPtr<FdoIConnection> connection = UnitTestUtil::GetConnection(DB_SUFFIX);
FdoPtr<FdoITransaction> featureTransaction = connection->BeginTransaction();
FdoPtr<FdoIInsert>insertCommand = (FdoIInsert *) connection->CreateCommand(FdoCommandType_Insert);
// Add an instance of the TestClass
insertCommand->SetFeatureClassName(L"TestClass");
FdoPtr<FdoPropertyValueCollection> propertyValues = insertCommand->GetPropertyValues();
// Add the id property
FdoPtr<FdoDataValue>dataValue = FdoDataValue::Create( 11 );
FdoPtr<FdoPropertyValue>propertyValue = AddNewProperty( propertyValues, L"Id");
propertyValue->SetValue(dataValue);
// Add the name one property
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"Name One");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Name Two");
propertyValue->SetValue(dataValue);
FdoPtr<FdoIFeatureReader> reader = insertCommand->Execute();
// Add an instance of the TestFeatureClass
insertCommand->SetFeatureClassName(L"TestSubFeatureClass");
propertyValues = insertCommand->GetPropertyValues();
propertyValues->Clear();
// Add the id property
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"First Name");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Last Name");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create( 10 );
propertyValue = AddNewProperty( propertyValues, L"Id");
propertyValue->SetValue(dataValue);
// Add the id property
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"Object.First Name");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Object.Last Name");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create( 10 );
propertyValue = AddNewProperty( propertyValues, L"Object.Id");
propertyValue->SetValue(dataValue);
if( type == Insert_NoIdentity )
{
dataValue = FdoDataValue::Create( 11 );
propertyValue = AddNewProperty( propertyValues, L"Object.Association Prop1.Id");
propertyValue->SetValue(dataValue);
}
else if( type == Insert_NoIdentityObjNested )
{
dataValue = FdoDataValue::Create( name1 );
propertyValue = AddNewProperty( propertyValues, L"Object.LeafObject.First Name");
propertyValue->SetValue(dataValue);
// Add the name two property
dataValue = FdoDataValue::Create( name2 );
propertyValue = AddNewProperty( propertyValues, L"Object.LeafObject.Last Name");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create( 10 );
propertyValue = AddNewProperty( propertyValues, L"Object.LeafObject.Id");
propertyValue->SetValue(dataValue);
dataValue = FdoDataValue::Create( 11 );
propertyValue = AddNewProperty( propertyValues, L"Object.LeafObject.Association Prop1.Id");
propertyValue->SetValue(dataValue);
}
reader = insertCommand->Execute();
featureTransaction->Commit();
}
catch(FdoException *exp )
{
printf("Insert Master Test Error: %ls\n", exp->GetExceptionMessage() );
UnitTestUtil::PrintException(exp, UnitTestUtil::GetOutputFileName( L"TestSchema.txt" ) );
exp->Release();
CPPUNIT_FAIL ( "Insert Master Test(WITH OBJ) exception" );
}
}
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();
}
/// <summary>Executes the release lock command, returning an FdoILockConflictReader.</summary>
/// <returns>Returns an FdoILockConflictReader</returns>
FdoILockConflictReader* ArcSDEReleaseLockCommand::Execute ()
{
const CHAR* columns[1];
FdoPtr<ArcSDEConnection> connection;
CHAR table[SE_QUALIFIED_TABLE_NAME];
CHAR column[SE_MAX_COLUMN_LEN];
wchar_t* wcolumn;
CHAR *where;
SHORT count;
SE_FILTER* filters;
FdoString* property;
LONG result;
SE_STREAM stream;
CHAR user_name[SE_MAX_OWNER_LEN];
wchar_t* me;
CHAR logfile[SE_MAX_PATH_LEN];
SE_SQL_CONSTRUCT sql_construct;
CHAR* tables[1];
FdoPtr<FdoISQLDataReader> reader;
SE_LOG log;
LONG number = 0;
Lock* locks = NULL;
wchar_t* locktable = NULL;
FdoPtr<ArcSDELockConflictReader> ret;
// verify the connection
connection = static_cast<ArcSDEConnection*>(GetConnection ());
if (connection == NULL)
throw FdoException::Create (NlsMsgGet (ARCSDE_CONNECTION_NOT_ESTABLISHED, "Connection not established."));
// verify the feature class name is specified
if (mClassName == NULL)
throw FdoException::Create (NlsMsgGet (ARCSDE_FEATURE_CLASS_UNSPECIFIED, "Feature class name not specified."));
// get the class definition which reflects the requested feature class name
FdoPtr<FdoClassDefinition> definition = connection->GetRequestedClassDefinition (mClassName);
// get the filter if any
FdoPtr<FdoFilter> filter = GetFilter ();
// get SQL query's "from" table list
mConnection->ClassToTable (table, definition);
// ensure lockable table
if (!ArcSDELockUtility::IsLockable (connection->GetConnection (), table, column))
{
wchar_t* wtable;
sde_multibyte_to_wide (wtable, table);
throw FdoException::Create (NlsMsgGet1 (ARCSDE_LOCKING_NOT_ENABLED, "Table '%1$ls' is not lock enabled.", wtable));
}
// get the property name that is the row_id
sde_multibyte_to_wide (wcolumn, column);
property = connection->ColumnToProperty (definition, wcolumn);
// get SQL query's "where" clause & spatial filters
where = NULL;
count = 0;
filters = NULL;
GetFilterInfo (connection, filter, definition, where, count, filters);
// establish an empty conflict reader
ret = new ArcSDELockConflictReader (connection, definition->GetQualifiedName (), table, property);
// initialize the stream query
result = SE_stream_create (connection->GetConnection (), &stream);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_ALLOC, "Cannot initialize SE_STREAM structure.");
// if necessary, version enable the stream
ArcSDELongTransactionUtility::VersionStream (connection, stream, table, false);
// release lock, don't return rows
result = SE_connection_get_user_name (connection->GetConnection (), user_name);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_USER_UNKNOWN, "Cannot determine current user.");
sde_multibyte_to_wide (me, user_name);
if (0 == wcscmp (GetLockOwner (), L""))
{
result = SE_stream_set_rowlocking (stream, SE_ROWLOCKING_UNLOCK_ON_QUERY
| SE_ROWLOCKING_LOCK_ONLY);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_LOCK, "Cannot set row locking on the stream.");
}
else if (0 == wcscmp (GetLockOwner (), me))
{
result = SE_stream_set_rowlocking (stream, SE_ROWLOCKING_UNLOCK_ON_QUERY
| SE_ROWLOCKING_FILTER_MY_LOCKS | SE_ROWLOCKING_LOCK_ONLY);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_LOCK, "Cannot set row locking on the stream.");
}
else
{
LONG *ids = NULL;
CHAR **users = NULL;
CHAR lt[SE_QUALIFIED_TABLE_NAME];
if (0)
throw FdoCommandException::Create (NlsMsgGet (ARCSDE_RELEASE_UNOWNED_LOCKS, "Releasing other owners locks is not supported."));
result = SE_table_get_rowlocks (connection->GetConnection(), table, &number, &ids, &users);
handle_sde_err<FdoCommandException>(connection->GetConnection(), result, __FILE__, __LINE__, ARCSDE_GET_ROW_LOCK_LIST_FAILED, "Failed to get the row lock list.");
if (0 != number)
{
// put the id's and users in an array of lock structures
locks = (Lock*)calloc (number, sizeof (Lock));
for (int i = 0; i < number; i++)
{
locks[i].id = ids[i];
sde_strcpy (sde_pus2wc(locks[i].user), sde_pcus2wc(users[i]));
}
qsort (locks, number, sizeof (LONG), compare);
ArcSDELockUtility::LockTableName (lt, connection, table);
sde_multibyte_to_wide (locktable, lt);
SE_table_free_rowlocks_list (number, ids, users);
}
}
// apply attribute and spatial query to stream
columns[0] = column;
ApplyFilterInfoToStream (connection, stream, table, where, 1, columns, count, filters);
// set up a temporary log file
mConnection->MakeLog (&log, table);
// accumulate the query in the log file
result = SE_stream_set_logfile (stream, log, FALSE);
handle_sde_err<FdoCommandException> (stream, result, __FILE__, __LINE__, ARCSDE_LOG_SET_LOGFILE, "Could not set log file.");
// lock the table's lock table to prevent alteration
reader = ArcSDELockUtility::LockLockTable (mConnection, table);
// actually execute the query
result = SE_stream_execute (stream);
handle_sde_err<FdoCommandException>(stream, result, __FILE__, __LINE__, ARCSDE_STREAM_EXECUTE, "Stream execute failed.");
result = SE_stream_fetch (stream);
// three possibilities: locks for the specified user exist (SE_SUCCESS) and the log file isn't filled,
// everything was unlocked (SE_FINISHED)
// or there was a conflict (SE_LOCK_CONFLICT)
switch (result)
{
case SE_SUCCESS:
if (0 != number)
{
CHAR* user;
LONG id;
wchar_t drop[1024];
FdoPtr<FdoISQLCommand> sql;
Lock key;
Lock* item;
// Get lock owner name:
const wchar_t *wLockOwner = GetLockOwner();
wchar_t *wLockOwnerUpr = (wchar_t*)alloca( (1+wcslen(wLockOwner)) * sizeof(wchar_t));
wcscpy(wLockOwnerUpr, wLockOwner);
FdoCommonOSUtil::wcsupr(wLockOwnerUpr); // ToDo: Oracle-specific
sde_wide_to_multibyte (user, wLockOwnerUpr);
// process each row returned (ignoring the log file)
sql = (FdoISQLCommand*)connection->CreateCommand (FdoCommandType_SQLCommand);
do
{
if (SE_SUCCESS != (result = SE_stream_get_integer (stream, 1, &id)))
{
sde_multibyte_to_wide (wcolumn, column);
handle_sde_err<FdoCommandException> (stream, result, __FILE__, __LINE__, ARCSDE_STREAM_GET, "Stream get ('%1$ls') failed for column '%2$ls'.", L"SE_stream_get_integer", wcolumn);
}
else
{
key.id = id;
// look it up to see if it's a conflict (i.e. not found)
if (NULL != (item = (Lock*)bsearch (&key, locks, number, sizeof (LONG), compare)))
{
if (0 == sde_strcmp (sde_pcus2wc(user), sde_pcus2wc(item->user)))
{
// ToDo: optimize this singleton delete somewhat
//ROW_ID NOT NULL NUMBER(38)
//USER_NAME NOT NULL VARCHAR2(32)
FdoCommonOSUtil::swprintf (drop, ELEMENTS (drop), L"delete from %ls where user_name=upper('%ls') and row_id = %ld", locktable, GetLockOwner (), id);
sql->SetSQLStatement (drop);
sql->ExecuteNonQuery ();
}
else
ret->AddIdentity (id);
}
else
{
// no lock, hence no conflict
}
}
}
while (SE_SUCCESS == (result = SE_stream_fetch (stream)));
if (SE_FINISHED != result)
handle_sde_err<FdoCommandException> (stream, result, __FILE__, __LINE__, ARCSDE_STREAM_FETCH, "Stream fetch failed.");
}
break;
case SE_FINISHED:
break;
case SE_LOCK_CONFLICT:
// reuse the same stream
result = SE_stream_close (stream, TRUE);
// if necessary, version enable the stream
ArcSDELongTransactionUtility::VersionStream (connection, stream, table, false);
// select locks still remaining
result = SE_stream_set_rowlocking (stream, SE_ROWLOCKING_FILTER_OTHER_LOCKS);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_LOCK, "Cannot set row locking on the stream.");
// get the list of row ids from the log file
tables[0] = table;
sql_construct.tables = tables;
sql_construct.num_tables = ELEMENTS (tables);
sql_construct.where = NULL;
ArcSDELockUtility::GetLogFile (logfile, connection->GetConnection (), log);
result = SE_stream_query_logfile (stream, logfile, 1, columns, &sql_construct);
handle_sde_err<FdoCommandException>(stream, result, __FILE__, __LINE__, ARCSDE_LOG_FILE_QUERY, "Unable to query log file.");
// execute the query that fetches conflicts
result = SE_stream_execute (stream);
handle_sde_err<FdoCommandException>(stream, result, __FILE__, __LINE__, ARCSDE_STREAM_EXECUTE, "Stream execute failed.");
// gather the conflicts
ArcSDELockUtility::GatherConflicts (stream, column, 1, ret);
// if there were conflicts (and there will be), do a partial unlock
if (0 != ret->mIds->GetCount ())
{
// reuse the same stream
result = SE_stream_close (stream, TRUE);
// if necessary, version enable the stream
ArcSDELongTransactionUtility::VersionStream (connection, stream, table, false);
// select locks still remaining
result = SE_stream_set_rowlocking (stream, SE_ROWLOCKING_FILTER_MY_LOCKS | SE_ROWLOCKING_UNLOCK_ON_QUERY | SE_ROWLOCKING_LOCK_ONLY);
handle_sde_err<FdoCommandException> (connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_LOCK, "Cannot set row locking on the stream.");
// get the list of row ids from the log file
result = SE_stream_query_logfile (stream, logfile, 1, columns, &sql_construct);
handle_sde_err<FdoCommandException>(stream, result, __FILE__, __LINE__, ARCSDE_LOG_FILE_QUERY, "Unable to query log file.");
// execute the query that unlocks rows
result = SE_stream_execute (stream);
handle_sde_err<FdoCommandException>(stream, result, __FILE__, __LINE__, ARCSDE_STREAM_EXECUTE, "Stream execute failed.");
}
else
throw FdoException::Create (NlsMsgGet(ARCSDE_UNEXPECTED_ERROR, "Unexpected error encountered in ArcSDE Provider."));
break;
default:
handle_sde_err<FdoCommandException> (stream, result, __FILE__, __LINE__, ARCSDE_STREAM_FETCH, "Stream fetch failed.");
}
// release the transaction lock
if (reader != NULL)
reader->Close ();
// clean up
if (NULL != locks)
free(locks);
result = SE_stream_free (stream);
handle_sde_err<FdoCommandException>(connection->GetConnection (), result, __FILE__, __LINE__, ARCSDE_STREAM_FREE, "Stream free failed.");
delete[] where;
if (NULL != filters)
{
for (int i = 0; i < count; i++)
if (NULL != filters[i].filter.shape)
SE_shape_free (filters[i].filter.shape);
delete[] filters;
}
return (FDO_SAFE_ADDREF (ret.p));
}