FdoFunctionDefinition* ExpressionFunctionArgb::GetFunctionDefinition()
{
if (!m_functionDefinition)
{
STRING funcDesc = MgUtil::GetResourceMessage(MgResources::Stylization, L"MgFunctionARGB_Description");
STRING aValDesc = MgUtil::GetResourceMessage(MgResources::Stylization, L"MgFunctionARGB_AValueDescription");
STRING rValDesc = MgUtil::GetResourceMessage(MgResources::Stylization, L"MgFunctionARGB_RValueDescription");
STRING gValDesc = MgUtil::GetResourceMessage(MgResources::Stylization, L"MgFunctionARGB_GValueDescription");
STRING bValDesc = MgUtil::GetResourceMessage(MgResources::Stylization, L"MgFunctionARGB_BValueDescription");
FdoPtr<FdoArgumentDefinition> arg1 = FdoArgumentDefinition::Create(L"aValue", aValDesc.c_str(), FdoDataType_Int32); // NOXLATE
FdoPtr<FdoArgumentDefinition> arg2 = FdoArgumentDefinition::Create(L"rValue", rValDesc.c_str(), FdoDataType_Int32); // NOXLATE
FdoPtr<FdoArgumentDefinition> arg3 = FdoArgumentDefinition::Create(L"gValue", gValDesc.c_str(), FdoDataType_Int32); // NOXLATE
FdoPtr<FdoArgumentDefinition> arg4 = FdoArgumentDefinition::Create(L"bValue", bValDesc.c_str(), FdoDataType_Int32); // NOXLATE
FdoPtr<FdoArgumentDefinitionCollection> args = FdoArgumentDefinitionCollection::Create();
args->Add(arg1);
args->Add(arg2);
args->Add(arg3);
args->Add(arg4);
m_functionDefinition = FdoFunctionDefinition::Create(L"ARGB", // NOXLATE
funcDesc.c_str(),
FdoDataType_Int32,
args,
FdoFunctionCategoryType_String,
false);
}
return FDO_SAFE_ADDREF(m_functionDefinition);
}
FdoExpressionEngineFunctionCollection* FdoRdbmsSelectCommand::GetUserDefinedFunctions( FdoSmLpSpatialContextCollection *scColl, FdoClassDefinition *classDef )
{
// Length2D and Area2D require to pass in the 'geodetic' flag.
// Check the associated coordinate system. In case it is geodetic, create a custom function.
FdoPtr<FdoExpressionEngineFunctionCollection> userDefinedFunctions;
if (classDef->GetClassType() == FdoClassType_FeatureClass)
{
FdoPtr<FdoGeometricPropertyDefinition> gpd = ((FdoFeatureClass*)classDef)->GetGeometryProperty();
if ( gpd )
{
FdoStringP scname = gpd->GetSpatialContextAssociation();
if ( scname.GetLength() != 0 )
{
FdoSmLpSpatialContextP sc = scColl->FindItem( scname );
FdoStringP wkt = sc->GetCoordinateSystemWkt();
if ( wkt.Contains( L"PROJCS" ) )
; // do nothing
else if ( wkt.Contains( L"GEOGCS" ) )
{
userDefinedFunctions = FdoExpressionEngineFunctionCollection::Create();
userDefinedFunctions->Add( FdoFunctionLength2D::Create(true));
userDefinedFunctions->Add( FdoFunctionArea2D::Create(true));
}
}
}
}
return FDO_SAFE_ADDREF(userDefinedFunctions.p);
}
/* 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 CGwsPreparedFeatureQuery::PrepareInternal ()
{
CGwsFdoCommand::PrepareNonKeyProperties ();
if(m_selectList->GetCount() > 0)
{
//add in the select ilst, along with the identity properties, revision number
WSTRARRAY strNames;
bool bFoundRevision = false;
for (FdoInt32 idx = 0; m_identity != NULL && idx < m_identity->GetCount(); idx ++)
{
FdoPtr<FdoDataPropertyDefinition> pPropdef = m_identity->GetItem(idx);
FdoString* pName = pPropdef->GetName();
bool bFound = false;
for (int i = 0; i < m_selectList->GetCount(); i++)
{
FdoPtr<FdoIdentifier> selProp = m_selectList->GetItem(i);
FdoString * selectName = selProp->GetName();
if(wcscmp(pName,selectName) == 0)
bFound = true;
if(idx==0 && wcscmp(m_revisionprop.c_str (), selectName) == 0)
bFoundRevision = true;
}
if(!bFound)
strNames.push_back(pName);
}
if(!bFoundRevision && !m_revisionprop.empty())
strNames.push_back(m_revisionprop.c_str());
FdoPtr<FdoIdentifierCollection> lst = ((FdoIBaseSelect*)m_pCommand.p)->GetPropertyNames();
if (lst != NULL)
{
lst->Clear();
if(!m_bIsSelectDistinct)
{
//add identity properties
for (unsigned int i = 0; i < strNames.size(); i++)
{
FdoPtr<FdoIdentifier> pIdent = FdoIdentifier::Create (strNames[i].c_str());
lst->Add(pIdent);
}
}
for (int i = 0; i < m_selectList->GetCount(); i++)
{
FdoPtr<FdoIdentifier> pIdent = m_selectList->GetItem(i);
lst->Add(pIdent);
}
}
}
}
MgReader* MgSelectCommand::Execute()
{
FdoPtr<FdoIFeatureReader> reader;
// Break up the filter into smaller chunks
FdoPtr<MgFdoFilterCollection> subFilters = this->GetSubFilters();
CHECKNULL((FdoISelect*)m_command, L"MgSelectCommand.Execute");
// Execute queries using the smaller filters and collect the results of the queries into a reader collection.
FdoPtr<MgFdoReaderCollection> frc = MgFdoReaderCollection::Create();
for (FdoInt32 filterIndex = 0; filterIndex < subFilters->GetCount(); filterIndex++)
{
FdoPtr<FdoFilter> filter = subFilters->GetItem(filterIndex);
m_command->SetFilter(filter);
reader = m_command->Execute();
frc->Add(reader);
}
FdoPtr<MgFdoFeatureReader> featureReader = new MgFdoFeatureReader(frc);
CHECKNULL((FdoIFeatureReader*)featureReader, L"MgSelectCommand.Execute");
return new MgServerFeatureReader(m_connection, featureReader);
}
/////////////////////////////////////////////////////////////////////
//
// 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);
}
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 ExpressionFunctionLookup::AddSignatures(FdoSignatureDefinitionCollection* signatures,
FdoArgumentDefinition* expression, FdoArgumentDefinition* defaultValue,
FdoArgumentDefinition* index, FdoArgumentDefinition* value, FdoDataType returnType)
{
for (int num=1; num<=MAX_LOOKUP_SIGNATURE_SIZE; ++num)
{
FdoPtr<FdoArgumentDefinitionCollection> args = FdoArgumentDefinitionCollection::Create();
args->Add(expression);
args->Add(defaultValue);
for (int i=0; i<num; ++i)
{
args->Add(index);
args->Add(value);
}
FdoPtr<FdoSignatureDefinition> sig = FdoSignatureDefinition::Create(returnType, args);
signatures->Add(sig);
}
}
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()) );
}
SuperMapLpPropertyDefinition::SuperMapLpPropertyDefinition(SuperMapLpClassDefinition *parentLpClass, UGC::UGDatasetVector* pDatasetVector, UGC::UGFieldInfo* fieldInfo, FdoPropertyDefinition* configLogicalProperty)
:
m_fieldInfo(fieldInfo),
m_parentLpClass(parentLpClass) // week reference
{
if(m_fieldInfo != NULL)
ConvertPhysicalToLogical(m_fieldInfo);
else
ConvertLogicalToPhysical(pDatasetVector,configLogicalProperty);
// 把逻辑物理属性添加到父逻辑物理类中
FdoPtr<SuperMapLpPropertyDefinitionCollection> lpProperties = m_parentLpClass->GetLpProperties();
if (!lpProperties->Contains (GetName ()))
lpProperties->Add(this);
}
FdoCurveSegmentCollection* FdoFgfCurveString::GetCurveSegments() const
{
// Get count
FdoInt32 numSegs = this->GetCount();
FdoPtr<FdoCurveSegmentCollection> curveSegs = FdoCurveSegmentCollection::Create();
for (FdoInt32 i=0; i<numSegs; i++)
{
FdoPtr<FdoICurveSegmentAbstract> seg = this->GetItem(i);
curveSegs->Add(seg);
}
return FDO_SAFE_ADDREF(curveSegs.p);
}
// Returns an array of FunctionDefinitions the feature provider supports
// within expressions. The length parameter gives the number of function
// definitions in the array.
FdoFunctionDefinitionCollection* FdoRdbmsSqlServerExpressionCapabilities::GetFunctions()
{
if (NULL == m_supportedFunctions)
{
m_supportedFunctions = FdoExpressionEngine::GetStandardFunctions();
FdoPtr<FdoExpressionEngineFunctionCollection> customFuncs = FdoExpressionEngineFunctionCollection::Create();
FdoPtr<FdoExpressionEngineIFunction> func1 = FdoRdbmsFunctionIsValid::Create();
m_supportedFunctions->Add(FdoPtr<FdoFunctionDefinition>(func1->GetFunctionDefinition()));
customFuncs->Add( func1 );
FdoExpressionEngine::RegisterFunctions( customFuncs );
}
if (m_serverFunctions == NULL)
{
m_serverFunctions = FdoFunctionDefinitionCollection::Create();
bool rVal = m_conn->GetServerSideFunctionCollection(m_serverFunctions);
if (rVal && m_serverFunctions->GetCount())
{
FdoPtr<FdoExpressionEngineFunctionCollection> customFuncs = FdoExpressionEngineFunctionCollection::Create();
for(int idx = 0; idx < m_serverFunctions->GetCount(); idx++)
{
FdoPtr<FdoFunctionDefinition> fctDef = m_serverFunctions->GetItem(idx);
FdoPtr<FdoExpressionEngineIFunction> fct = FdoRdbmsCustomFunction::Create(fctDef);
customFuncs->Add (fct);
m_supportedFunctions->Add(fctDef);
}
FdoExpressionEngine::RegisterFunctions (customFuncs);
}
else // was server ready to provide them?
m_serverFunctions = NULL;
}
return FDO_SAFE_ADDREF(m_supportedFunctions.p);
}
/// <summary>Executes the GetSpatialContexts command returning an FdoISpatialContextReader.</summary>
/// <returns>Returns nothing</returns>
FdoISpatialContextReader* FdoRfpGetSpatialContexts::Execute()
{
FdoPtr<FdoRfpSpatialContextCollection> spatialContexts;
FdoRfpConnectionP conn = static_cast<FdoRfpConnection*>(GetConnection());
if (m_bActiveOnly)
{
spatialContexts = new FdoRfpSpatialContextCollection();
spatialContexts->Add(conn->GetActiveSpatialContext());
}
else
spatialContexts = conn->GetSpatialContexts();
FdoRfpSpatialContextReaderP reader = new FdoRfpSpatialContextReader(spatialContexts, conn->GetActiveSpatialContext()->GetName());
return FDO_SAFE_ADDREF(reader.p);
}
FdoIGeometry* FdoXmlMultiGeometry::GetFdoGeometry()
{
//create geometry collection
FdoPtr<FdoGeometryCollection> geometryCollection = FdoGeometryCollection::Create();
for(vector<FdoXmlGeometry*>::iterator it = m_geometryCollection.begin();
it != m_geometryCollection.end();
it++)
{
FdoPtr<FdoIGeometry> fdoGeometry = (*it)->GetFdoGeometry();
if(fdoGeometry != NULL)
geometryCollection->Add(fdoGeometry);
}
//convert to FdoIMultiGeometry
FdoPtr<FdoFgfGeometryFactory> factory = FdoFgfGeometryFactory::GetInstance();
FdoPtr<FdoIGeometry> rv;
if (geometryCollection->GetCount() != 0)
rv = factory->CreateMultiGeometry(geometryCollection);
return FDO_SAFE_ADDREF(rv.p);
}
/* Test spatial filter. */
void BasicUpdateTests::spatial_filter ()
{
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcovSingleDb());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
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 ((5010.282 5011.717, 5010.4 5011.7, 5010.4 5011.3, 5010.282 5011.717))')");
value = FdoPropertyValue::Create ((FdoString*)GetGeomPropName(), expression);
values->Add (value);
FdoPtr<FdoIFeatureReader> reader = insert->Execute ();
int id1;
while (reader->ReadNext ())
id1 = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
value = values->GetItem (Data[0]->mPropertyName);
expression = (FdoValueExpression*)FdoExpression::Parse (L"'John Smith'");
value->SetValue (expression);
value = values->GetItem ((FdoString*)GetGeomPropName());
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5000.919 5000.277, 5000.5 5000.2, 5000.5 5000.7, 5000.919 5000.277))')");
value->SetValue (expression);
reader = insert->Execute ();
int id2;
while (reader->ReadNext ())
id2 = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
value = values->GetItem (Data[0]->mPropertyName);
expression = (FdoValueExpression*)FdoExpression::Parse (L"'Mott the Hoople'");
value->SetValue (expression);
value = values->GetItem ((FdoString*)GetGeomPropName());
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5014.262 5015.018, 5014.3 5015.9, 5014.9 5015.9, 5014.262 5015.018))')");
value->SetValue (expression);
reader = insert->Execute ();
int id3;
while (reader->ReadNext ())
id3 = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
// do a spatial filtered update
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (L"SHAPE INTERSECTS GEOMFROMTEXT ('POLYGON XY (( 5012 5012, 5020 5012, 5020 5016, 5012 5016, 5012 5012 ))')")));
values = update->GetPropertyValues ();
expression = (FdoValueExpression*)FdoExpression::Parse (L"'Alice in Wonderland'");
value = FdoPropertyValue::Create (Data[0]->mPropertyName, expression);
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::QClassNameTestClassComplex());
reader = select->Execute ();
int id;
while (reader->ReadNext ())
{
id = reader->GetInt32 ((FdoString*)GetIdPropName());
FdoString* item = reader->GetString (Data[0]->mPropertyName);
if (id == id3)
CPPUNIT_ASSERT_MESSAGE ("value not changed", 0 == wcscmp (item, L"Alice in Wonderland"));
else
CPPUNIT_ASSERT_MESSAGE ("value mistakenly changed", 0 != wcscmp (item, L"Alice in Wonderland"));
}
reader->Close();
// Clean up after test:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
}
catch (FdoException* ge)
{
fail (ge);
}
}
/* Test insert/update/select on a table that has a UUID column. */
void BasicUpdateTests::update_uuid ()
{
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcov());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassUuid(), ArcSDETestConfig::ClassNameTestClassUuid(), true);
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassUuid());
FdoPtr<FdoPropertyValueCollection> values = insert->GetPropertyValues ();
FdoPtr<FdoStringValue> expression = FdoStringValue::Create (L"Added");
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create (AdjustRdbmsName(L"MYSTRING"), expression);
values->Add (value);
FdoPtr<FdoIFeatureReader> reader = insert->Execute ();
expression->SetString(L"Updated");
reader = insert->Execute ();
expression->SetString(L"Deleted");
reader = insert->Execute ();
FdoStringP addedUuid1;
FdoStringP updatedUuid1;
FdoStringP deletedUuid;
FdoStringP updatedUuid2 = L"{ABCDEFGH-IJKL-MNOP-QRST-UVWXYZ123456}";
FdoStringP addedUuid3;
FdoStringP updatedUuid3;
FdoPtr<FdoISelect> select = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
select->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassUuid());
reader = select->Execute ();
while (reader->ReadNext ())
{
FdoStringP myString = reader->GetString(AdjustRdbmsName(L"MYSTRING"));
if ( myString == L"Added" )
addedUuid1 = reader->GetString(AdjustRdbmsName(L"ID"));
else if ( myString == L"Updated" )
updatedUuid1 = reader->GetString(AdjustRdbmsName(L"ID"));
else if ( myString == L"Deleted" )
deletedUuid = reader->GetString(AdjustRdbmsName(L"ID"));
}
reader->Close();
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassUuid());
FdoStringP filter = FdoStringP::Format( L"%ls = '%ls'", (FdoString*) AdjustRdbmsName(L"ID"), (FdoString*) updatedUuid1 );
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
values = update->GetPropertyValues ();
value = FdoPropertyValue::Create ();
value->SetName (AdjustRdbmsName(L"ID"));
expression = FdoStringValue::Create (updatedUuid2);
value->SetValue (expression);
values->Add (value);
bool updateFailed = false;
// ID is readonly so update should fail.
try
{
update->Execute ();
}
catch ( FdoException* ex )
{
ex->Release();
updateFailed = true;
}
CPPUNIT_ASSERT ("update failed");
FdoPtr<FdoIDelete> dlte = (FdoIDelete*)mConnection->CreateCommand (FdoCommandType_Delete);
dlte->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassUuid());
filter = FdoStringP::Format( L"%ls = '%ls'", (FdoString*) AdjustRdbmsName(L"ID"), (FdoString*) deletedUuid );
dlte->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
if (1 != dlte->Execute ())
CPPUNIT_FAIL ("delete execute failed");
// check by doing a select
select = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
select->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassUuid());
reader = select->Execute ();
int count = 0;
while (reader->ReadNext ())
{
count++;
FdoStringP myString = reader->GetString(AdjustRdbmsName(L"MYSTRING"));
if ( myString == L"Added" )
addedUuid3 = reader->GetString(AdjustRdbmsName(L"ID"));
else if ( myString == L"Updated" )
updatedUuid3 = reader->GetString(AdjustRdbmsName(L"ID"));
}
reader->Close();
CPPUNIT_ASSERT( count == 2 );
CPPUNIT_ASSERT( addedUuid3 == addedUuid1 );
CPPUNIT_ASSERT( updatedUuid3 == updatedUuid1 );
CPPUNIT_ASSERT( updatedUuid3 != updatedUuid2 );
mConnection->Close();
}
catch (FdoException* ge)
{
fail (ge);
}
}
/* 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);
}
}
EGwsStatus CGwsPreparedFeatureQuery::Init (
FdoIdentifierCollection * sellist,
FdoStringCollection * orderBy,
FdoOrderingOption orderingOption,
FdoFilter * pFilter
)
{
EGwsStatus stat = eGwsOk;
stat = CGwsFdoCommand::Init ();
if (IGWSException::IsError (stat))
return stat;
try {
// TODO: this code below can be called by the client very often
// need to optimize it in terms of minimazing calles to the init
// Client ideally should do init once and repeatedly call SetFilter
// and execute
assert(m_classDef != NULL); //set in CGwsFdoCommand::Init ();
FdoPtr<IGWSQueryDefinition> qDef;
m_pQuery->GetQueryDefinition(&qDef);
IGWSJoinQueryDefinition* jqd = dynamic_cast<IGWSJoinQueryDefinition*>(qDef.p);
if(m_resultDescriptor != NULL)
{
m_resultDescriptor->Release();
}
if(jqd)
m_resultDescriptor = new CGwsQueryResultDescriptors (m_classDef, m_classname, jqd->JoinName(), jqd->JoinDelimiter(), jqd->ForceOneToOne(), sellist, qDef->Type() == eGwsQueryLeftOuterJoin);
else
m_resultDescriptor = new CGwsQueryResultDescriptors (m_classDef, m_classname, NULL, NULL, true, sellist);
m_resultDescriptor->AddRef ();
const CGwsPropertyDesc & propdsc = m_resultDescriptor->GetGeometryPropertyDescriptor ();
if (propdsc.m_name.length () != 0) {
GwsSpatialContextDescription desc;
GwsCommonFdoUtils::DescribeSC (m_connection,
propdsc.m_spatialcontext.c_str (),
desc);
m_resultDescriptor->SetCSName (desc.CsName ());
}
if (sellist != NULL) {
for (int i = 0; i < sellist->GetCount (); i ++) {
m_selectList->Add (FdoPtr<FdoIdentifier>(sellist->GetItem (i)));
}
}
m_revisionprop.clear ();
m_revisionprop = GwsCommonFdoUtils::GetRevisionProperty (m_classDef);
//attempt to build an scrollable select command and, if that fails,
//attempt to build a standard select comand
FdoISelect * selcmd = NULL;
FdoInt32 size = 0;
FdoPtr<FdoICommandCapabilities> ptrCap = m_connection->GetCommandCapabilities();
FdoInt32* pTypes = ptrCap->GetCommands(size);
for(int i = 0; i < size; i++ )
{
if( pTypes[i] == FdoCommandType_ExtendedSelect)
{
m_bExtendedQuerySupported = true;
selcmd = (FdoIExtendedSelect *) m_connection->CreateCommand (FdoCommandType_ExtendedSelect);
mExSelProv = eFDO;
break;
}
}
if(!m_bExtendedQuerySupported)
selcmd = (FdoISelect *) m_connection->CreateCommand (FdoCommandType_Select);
selcmd->SetFeatureClassName(GwsCommonFdoUtils::MakeFdoQualifiedName (m_classname).c_str());
if (orderBy != NULL && orderBy->GetCount () > 0) {
FdoPtr<FdoIdentifierCollection> order = selcmd->GetOrdering ();
for (int i = 0; i < orderBy->GetCount (); i ++) {
FdoPtr<FdoIdentifier> ident = FdoIdentifier::Create (orderBy->GetString (i));
order->Add (ident);
}
if(m_bExtendedQuerySupported)
{
if(mExSelProv == eFDO)
{
FdoIExtendedSelect* pExSelCmd = (FdoIExtendedSelect*)selcmd;
pExSelCmd->SetOrderingOption(orderBy->GetString(0), orderingOption);
}
}
else
{
selcmd->SetOrderingOption(orderingOption);
}
}
m_pCommand = selcmd;
SetFilter (pFilter);
// selcmd->SetFilter (pFilter);
} catch (FdoException * fdoEx) {
PushFdoException (eGwsFdoProviderError, fdoEx);
fdoEx->Release ();
stat = eGwsFdoProviderError;
}
return stat;
}
MgFdoFilterCollection* MgSelectCommand::GetSubFilters()
{
// Break up a filter into a bunch of smaller filters
// For now we just reduce a simple case with datastore limitations in handling the number of OR conditions.
// This is the case where a filter has only OR spatial conditions that can be broken up into a collection
// of smaller OR filters.
class FdoCommonFilterFragmenter : public virtual FdoIFilterProcessor
{
private:
FdoPtr<FdoFilter> m_newFilter;
FdoPtr<FdoIGeometry> m_geomRight;
FdoPtr<FdoIGeometry> m_geomLeft;
int m_OrCount;
std::vector<FdoFilter*> m_filters;
bool m_isFragmented;
protected:
void HandleFilter( FdoFilter *filter )
{
filter->Process( this );
}
public:
FdoCommonFilterFragmenter( ):m_isFragmented(true)
{
m_OrCount = 0;
m_filters.clear();
}
int GetOrCount() { return m_OrCount; }
std::vector<FdoFilter*>& GetFilters() { return m_filters; }
bool IsFragmented() { return m_isFragmented; }
FdoFilter* GetNewFilter() { return m_newFilter ? FDO_SAFE_ADDREF(m_newFilter.p) : NULL; }
virtual void Dispose()
{
delete this;
}
virtual void ProcessBinaryLogicalOperator(FdoBinaryLogicalOperator& filter)
{
if( filter.GetOperation() != FdoBinaryLogicalOperations_Or )
{
m_isFragmented = false;
return;
}
HandleFilter( FdoPtr<FdoFilter>(filter.GetRightOperand()) );
m_newFilter = filter.GetLeftOperand();
m_OrCount++;
}
virtual void ProcessComparisonCondition(FdoComparisonCondition& filter)
{
// Add filter to collection
m_filters.push_back(&filter);
return;
}
virtual void ProcessDistanceCondition(FdoDistanceCondition& filter)
{
m_isFragmented = false;
return;
}
virtual void ProcessInCondition(FdoInCondition& filter)
{
m_isFragmented = false;
return;
}
virtual void ProcessNullCondition(FdoNullCondition& filter)
{
m_isFragmented = false;
return;
}
virtual void ProcessSpatialCondition(FdoSpatialCondition& filter)
{
m_isFragmented = false;
return;
}
virtual void ProcessUnaryLogicalOperator(FdoUnaryLogicalOperator& filter)
{
m_isFragmented = false;
return;
}
};
FdoCommonFilterFragmenter fragmenter;
if (m_filter)
m_filter->Process( &fragmenter );
FdoPtr<FdoFilter> newFilter = fragmenter.GetNewFilter();
while (newFilter != NULL)
{
newFilter->Process( &fragmenter );
FdoPtr<FdoFilter> tempFilter = fragmenter.GetNewFilter();
if (tempFilter != newFilter)
{
newFilter = tempFilter;
}
else
{
newFilter = NULL;
}
}
#ifdef _DEBUG
int nCount = fragmenter.GetOrCount();
if ( nCount > 0)
{
char temp[1024];
sprintf(temp, "Or_Count = %d", nCount); // NOXLATE
printf("%s\n", temp);
}
#endif
FdoPtr<MgFdoFilterCollection> filters = MgFdoFilterCollection::Create();
if (fragmenter.IsFragmented() && fragmenter.GetOrCount() > 0)
{
int nSelectionCount = 0;
std::vector<FdoFilter*>::iterator filterIter;
bool bFirst = true;
FdoStringP filterString;
std::vector<FdoFilter*>& fragmentedFilters = fragmenter.GetFilters();
bool bIsAddedToCollection = false;
for (filterIter = fragmentedFilters.begin(); filterIter != fragmentedFilters.end(); filterIter++)
{
FdoStringP tempString = (*filterIter)->ToString();
FdoStringP orString = L" OR "; // NOXLATE
if (bFirst)
{
filterString = tempString;
bFirst = false;
}
else
{
filterString = filterString + orString + tempString;
nSelectionCount++;
}
if (nSelectionCount >= MG_MAX_SUBFILTER_SIZE)
{
FdoPtr<FdoFilter> filter = FdoFilter::Parse(filterString);
filters->Add(filter);
bFirst = true;
filterString = L"";
nSelectionCount = 0;
bIsAddedToCollection = true;
}
else
{
bIsAddedToCollection = false;
}
}
if ( !bIsAddedToCollection )
{
FdoPtr<FdoFilter> filter = FdoFilter::Parse(filterString);
filters->Add(filter);
}
}
else
{
filters->Add(m_filter);
}
return filters.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();
}
/* Test geometry update operation. */
void BasicUpdateTests::geometry_update ()
{
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcovSingleDb());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex()); // misnomer, it's not a feature class
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 ((5010.282 5011.717, 5011 5012, 5013 5012, 5010.282 5011.717))')");
FdoPtr<FdoPropertyValue> geometry = FdoPropertyValue::Create ((FdoString*)GetGeomPropName(), expression);
values->Add (geometry);
FdoPtr<FdoIFeatureReader> reader = insert->Execute ();
int id;
while (reader->ReadNext ())
id = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
value = values->GetItem (Data[0]->mPropertyName);
expression = (FdoValueExpression*)FdoExpression::Parse (L"'John Smith'");
value->SetValue (expression);
value = values->GetItem ((FdoString*)GetGeomPropName());
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5000.919 5000.277, 5005 5000, 5005 5005, 5000.919 5000.277))')");
value->SetValue (expression);
reader = insert->Execute ();
int id2;
while (reader->ReadNext ())
id2 = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
value = values->GetItem (Data[0]->mPropertyName);
expression = (FdoValueExpression*)FdoExpression::Parse (L"'Mott the Hoople'");
value->SetValue (expression);
value = values->GetItem ((FdoString*)GetGeomPropName());
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5014.262 5000.018, 5015 5005, 5016 5010, 5014.262 5000.018))')");
value->SetValue (expression);
reader = insert->Execute ();
int id3;
while (reader->ReadNext ())
id3 = reader->GetInt32 ((FdoString*)GetIdPropName());
reader->Close();
// update it
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
FdoPtr<FdoPropertyValueCollection> propertyValues = update->GetPropertyValues();
wchar_t filter[1024];
FdoCommonOSUtil::swprintf(filter, ELEMENTS(filter), L"%ls = %d", (FdoString*)GetIdPropName(), id);
FdoPtr<FdoFilter> fdoFilter = FdoFilter::Parse (filter);
update->SetFilter (fdoFilter);
values = update->GetPropertyValues ();
expression = (FdoValueExpression*)FdoExpression::Parse (L"GeomFromText('POLYGON XY ((5008.8 5004.7, 5010 5010, 5000 5005, 5008.8 5004.7))')");
value = FdoPropertyValue::Create ((FdoString*)GetGeomPropName(), expression);
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::QClassNameTestClassComplex());
fdoFilter = FdoFilter::Parse (filter);
select->SetFilter (fdoFilter);
reader = select->Execute ();
while (reader->ReadNext ())
{
FdoPtr<FdoGeometryValue> geometry = FDO_SAFE_ADDREF((FdoGeometryValue*)expression.p);
FdoPtr<FdoByteArray> fetched = reader->GetGeometry ((FdoString*)GetGeomPropName());
FdoString* referenceText = geometry->ToString();
FdoPtr<FdoGeometryValue> fetchedGeom = FdoGeometryValue::Create (fetched);
const wchar_t* fetchedText = fetchedGeom->ToString ();
CPPUNIT_ASSERT_MESSAGE ("incorrect geometry value", 0==wcscmp(referenceText, fetchedText));
}
reader->Close();
// Clean up after test:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
}
catch (FdoException* ge)
{
fail (ge);
}
}
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();
}
FdoIFeatureReader *FdoRdbmsSelectCommand::Execute( bool distinct, FdoInt16 callerId )
{
if (!mConnection || !mFdoConnection || mFdoConnection->GetConnectionState() != FdoConnectionState_Open)
throw FdoCommandException::Create(NlsMsgGet(FDORDBMS_13, "Connection not established"));
// Flush out any outstanding modifications before selecting; so that the select
// sees a current picture of the RDBMS.
mIConnection->Flush();
int qid = -1;
bool res = false;
bool delStatement = true;
GdbiStatement* statement = NULL;
const FdoSmLpClassDefinition *classDefinition = mConnection->GetSchemaUtil()->GetClass(this->GetClassNameRef()->GetText());
bool isFeatureClass = ( classDefinition != NULL && classDefinition->GetClassType() == FdoClassType_FeatureClass );
bool isForUpdate = HasLobProperty( classDefinition );
bool doNotUseSimpleSelect = mHasObjectProps && (mIdentifiers == NULL || mIdentifiers->GetCount() == 0);
try
{
// for now we support only select with joins
if (callerId == (FdoInt16)FdoCommandType_Select && !doNotUseSimpleSelect && !mHasObjectProps)
{
FdoPtr<FdoRdbmsSqlBuilder> sqlBuilder = mFdoConnection->GetSqlBuilder();
if (sqlBuilder)
{
std::vector<NameOrderingPair> ordering;
FdoPtr<FdoParameterValueCollection> params = GetParameterValues();
FdoPtr<FdoJoinCriteriaCollection> jcColl = GetJoinCriteria();
sqlBuilder->SetParameterValues(params);
if (mOrderingIdentifiers && mOrderingIdentifiers->GetCount())
{
for (int i=0; i<mOrderingIdentifiers->GetCount(); i++)
{
FdoPtr<FdoIdentifier> id = mOrderingIdentifiers->GetItem(i);
ordering.push_back(NameOrderingPair(id.p, ((int)mOrderingOptions.size() != mOrderingIdentifiers->GetCount()) ? mOrderingOption : mOrderingOptions[id->GetName()]));
}
}
FdoString* sqlString = sqlBuilder->ToSelectSqlString(GetClassNameRef(), mAliasName, GetFilterRef(), mIdentifiers, ordering, jcColl);
if (sqlString != NULL && *sqlString != '\0')
{
statement = mConnection->GetGdbiConnection()->Prepare( sqlString );
std::vector< std::pair< FdoLiteralValue*, FdoInt64 > >* paramsUsed = sqlBuilder->GetUsedParameterValues();
if (paramsUsed != NULL && paramsUsed->size())
{
if (mBindParamsHelper == NULL)
mBindParamsHelper = new FdoRdbmsPropBindHelper(mConn);
mBindParamsHelper->BindParameters(statement, paramsUsed);
}
GdbiQueryResult *queryRslt = statement->ExecuteQuery();
delete statement;
if (mBindParamsHelper != NULL)
mBindParamsHelper->Clear();
// statement will be deleted in the reader.
delStatement = false;
return FdoRdbmsSimpleFeatureReader::Create(mFdoConnection, queryRslt, isFeatureClass, classDefinition, NULL, mIdentifiers);
}
}
}
FdoPtr<FdoRdbmsFilterProcessor>flterProcessor = mFdoConnection->GetFilterProcessor();
FdoPtr<FdoParameterValueCollection> params = GetParameterValues();
flterProcessor->SetParameterValues(params);
FdoRdbmsFilterUtilConstrainDef filterConstrain;
filterConstrain.distinct = distinct;
filterConstrain.orderingOption = mOrderingOption;
filterConstrain.selectedProperties = mIdentifiers;
filterConstrain.groupByProperties = mGroupingCol;
filterConstrain.orderByProperties = mOrderingIdentifiers;
// Verify if this is a special case we can optimize (no filter, no grouping filter,
// and only aggregate functions Count() and/or SpatialExtents())
FdoRdbmsFeatureReader *reader = GetOptimizedFeatureReader( classDefinition );
if ( reader )
return reader;
// FDO supports expression functions that may not have native support in the
// underlying system. If this is the case then the request has to be handled
// by the Expression Engine.
bool isValidFilter = true,
isValidSelectList = true;
if ( this->GetFilterRef() != NULL )
isValidFilter = flterProcessor->IsValidExpression( this->GetFilterRef() );
isValidSelectList = flterProcessor->IsValidExpression( mIdentifiers );
if ( ( !isValidFilter ) || ( !isValidSelectList ) )
{
// Either the selected property list of the the filter is invalid. In any case
// create a SQL statement that selects all properties for the current class.
// If the filter is valid it is used to narrow the selected amount of data.
FdoString *sqlStatement =
flterProcessor->FilterToSql( ((isValidFilter)
? this->GetFilterRef()
: NULL),
this->GetClassNameRef()->GetText() );
GdbiQueryResult *queryRslt = mConnection->GetGdbiConnection()->ExecuteQuery( sqlStatement );
FdoPtr<FdoIFeatureReader> featureReader = new FdoRdbmsFeatureReader( mFdoConnection,
queryRslt,
isFeatureClass,
classDefinition,
NULL,
NULL,
0,
NULL );
// The Expression Engine cannot work with the class definition of type
// "FdoSmLpClassDefinition". Instead it is necessary to get the corresponding
// definition of type "FdoClassDefinition". This is done next.
const FdoSmLpSchema* schema = mConnection->GetSchema( this->GetClassNameRef()->GetText() );
FdoFeatureSchemasP fdoFeatureSchemas = mFdoConnection->GetSchemaManager()->GetFdoSchemas( schema->GetName() );
FdoClassesP classCol = (FdoClassCollection *)fdoFeatureSchemas->FindClass( this->GetClassNameRef()->GetText() );
FdoClassDefinitionP classDef = classCol->GetItem(0);
// Create the collection of custom functions.
FdoSmLpSchemasP schemas = ((FdoSmLpSchema *) schema)->GetSchemas();
FdoExpressionEngineFunctionCollection *userDefinedFunctions = GetUserDefinedFunctions( schemas->GetSpatialContextMgr()->GetSpatialContexts(), classDef );
return FdoExpressionEngineUtilFeatureReader::Create(
classDef,
featureReader,
this->GetFilterRef(),
mIdentifiers,
userDefinedFunctions);
}
// The selected properties and the filter are both valid. Do the normal processing.
// Validate the filter
if ( this->GetFilterRef() != NULL )
{
FdoPtr<FdoIFilterCapabilities> filterCaps = mFdoConnection->GetFilterCapabilities();
FdoExpressionEngine::ValidateFilter( NULL, this->GetFilterRef(), NULL, filterCaps);
}
// Call FilterToSql just to populate the filter's list of geometric conditions;
FdoString * sqlString = flterProcessor->FilterToSql( this->GetFilterRef(),
this->GetClassNameRef()->GetText(),
SqlCommandType_Select,
FdoCommandType_Select,
&filterConstrain,
isForUpdate,
callerId );
FdoPtr<FdoRdbmsFilterProcessor::BoundGeometryCollection> boundGeometries = flterProcessor->GetBoundGeometryValues();
FdoPtr<FdoRdbmsSecondarySpatialFilterCollection> geometricConditions = flterProcessor->GetGeometricConditions();
vector<int> * logicalOps = flterProcessor->GetFilterLogicalOps();
FdoPtr<FdoIdentifierCollection> idsWithGeoms = FdoIdentifierCollection::Create();
if (( mIdentifiers && mIdentifiers->GetCount() > 0) )
{
// Make sure that the properties are listed for any geometric conditions that require secondary filtering.
if (geometricConditions != NULL)
{
for (FdoInt32 i=0; i < geometricConditions->GetCount(); i++)
{
FdoPtr<FdoRdbmsSpatialSecondaryFilter> ssf = geometricConditions->GetItem(i);
FdoString * ssfPropertyName = ssf->GetPropertyName();
FdoPtr<FdoIdentifier> ssfId = mIdentifiers->FindItem(ssfPropertyName);
if (ssfId == NULL)
{
// Property wasn't selected by the caller.
ssfId = FdoIdentifier::Create(ssfPropertyName);
idsWithGeoms->Add(ssfId);
}
}
// Convert to SQL again if we added geometric properties.
if (idsWithGeoms->GetCount() > 0)
{
// Make our own copy of the original list, to avoid a side effect of changing
// mIdentifiers, which the user can effectively see. Perserve original order,
// effectively creating a new list that appends the geometry names.
for (FdoInt32 i = mIdentifiers->GetCount()-1; i >= 0; i--)
{
FdoPtr<FdoIdentifier> id = mIdentifiers->GetItem(i);
idsWithGeoms->Insert(0, id);
}
filterConstrain.selectedProperties = idsWithGeoms;
sqlString = flterProcessor->FilterToSql( this->GetFilterRef(),
this->GetClassNameRef()->GetText(),
SqlCommandType_Select,
FdoCommandType_Select,
&filterConstrain,
isForUpdate,
callerId );
}
}
if (callerId == FdoCommandType_SelectAggregates)
{
FdoSchemaManagerP pschemaManager = mConnection->GetSchemaUtil()->GetSchemaManager();
FdoPtr<FdoFeatureSchemaCollection> schemas = pschemaManager->GetFdoSchemas(L"");
FdoPtr<FdoCommonExpressionExecutor> expVer = FdoCommonExpressionExecutor::Create(schemas, GetClassNameRef());
FdoPtr<FdoIExpressionCapabilities> expCap = mFdoConnection->GetExpressionCapabilities();
expVer->ValidateIdentifiers(mIdentifiers, expCap);
}
}
statement = mConnection->GetGdbiConnection()->Prepare( sqlString );
std::vector< std::pair< FdoLiteralValue*, FdoInt64 > >* paramsUsed = flterProcessor->GetUsedParameterValues();
if (paramsUsed != NULL && paramsUsed->size())
{
if (mBindParamsHelper == NULL)
mBindParamsHelper = new FdoRdbmsPropBindHelper(mConn);
mBindParamsHelper->BindParameters(statement, paramsUsed);
}
GdbiQueryResult *queryRslt = statement->ExecuteQuery();
delete statement;
if (mBindParamsHelper != NULL)
mBindParamsHelper->Clear();
// statement will be deleted in the reader.
delStatement = false;
// For now only SQL Spatial Server supports SupportsSimpleReader, later (after we add some unit tests) we can extend it to other providers
if (!flterProcessor->ContainsCustomObjects() && flterProcessor->SupportsSimpleReader() && geometricConditions == NULL && callerId == (FdoInt16)FdoCommandType_Select && !doNotUseSimpleSelect)
{
return FdoRdbmsSimpleFeatureReader::Create(mFdoConnection, queryRslt, isFeatureClass, classDefinition, NULL, mIdentifiers);
}
else
{
if (( mIdentifiers && mIdentifiers->GetCount() > 0))
return new FdoRdbmsFeatureSubsetReader (mFdoConnection, queryRslt, isFeatureClass, classDefinition, NULL, mIdentifiers, geometricConditions, logicalOps );
else
return new FdoRdbmsFeatureReader (mFdoConnection, queryRslt, isFeatureClass, classDefinition, NULL, NULL, 0, geometricConditions, logicalOps ); // The feature reader should free the queryRslt
}
}
catch (FdoCommandException *ex)
{
if (delStatement)
delete statement;
ex;
SELECT_CLEANUP;
throw;
}
catch (FdoException *ex)
{
if (delStatement)
delete statement;
SELECT_CLEANUP;
// Wrap in FdoPtr to remove original reference to original exception
throw FdoCommandException::Create(ex->GetExceptionMessage(), FdoPtr<FdoException>(ex), ex->GetNativeErrorCode());
}
catch ( ... )
{
if (delStatement)
delete statement;
SELECT_CLEANUP;
throw;
}
}
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 SuperMapLpPropertyDefinition::ConvertPhysicalToLogical(UGC::UGFieldInfo* fieldInfo)
{
if(m_fieldInfo == NULL)
{
m_fieldInfo = fieldInfo;
}
VALIDATE_POINTER(m_fieldInfo);
// 逻辑的FDO属性名及为物理数据集的字段名
//FdoStringP pLogicalPropertyName = fieldInfo->m_strName;
FdoStringP pLogicalPropertyName = SuperMapUtil::StringToWString(fieldInfo->m_strName.Cstr()).c_str(); //modified by majun, 支持汉字字段
FdoString* logicalPropertyName = (FdoString*)pLogicalPropertyName;
FdoString* logicalPropertyDescription = L"";
// 创建逻辑属性
m_logicalProperty = FdoDataPropertyDefinition::Create(logicalPropertyName, logicalPropertyDescription);
// 属性字段物理属性转换
FdoDataType data_type ;
FdoInt32 nType = fieldInfo->m_nType; // ugc的字段类型
//TRACE(_T("SuperMapLpPropertyDefinition::ConvertPhysicalToLogical..[%ls]...[%d]\n"), logicalPropertyName, nType);
switch(nType)
{
case UGC::UGFieldInfo::Boolean:
data_type = FdoDataType_Boolean;
break;
case UGC::UGFieldInfo::Byte:
case UGC::UGFieldInfo::Char:
data_type = FdoDataType_Byte;
break;
case UGC::UGFieldInfo::Integer:
data_type = FdoDataType_Int16;
break;
case UGC::UGFieldInfo::Long:
data_type = FdoDataType_Int32;
break;
case UGC::UGFieldInfo::Single:
case UGC::UGFieldInfo::Float:
data_type = FdoDataType_Single;
break;
case UGC::UGFieldInfo::Double:
data_type = FdoDataType_Double;
break;
case UGC::UGFieldInfo::Date:
case UGC::UGFieldInfo::Time:
data_type = FdoDataType_DateTime;
break;
case UGC::UGFieldInfo::Decimal:
data_type = FdoDataType_Decimal;
break;
case UGC::UGFieldInfo::Binary:
case UGC::UGFieldInfo::LongBinary:
case UGC::UGFieldInfo::VarBinary:
case UGC::UGFieldInfo::TimeStamp:
data_type = FdoDataType_BLOB;
break;
case UGC::UGFieldInfo::Text:
case UGC::UGFieldInfo::Memo:
case UGC::UGFieldInfo::NVarChar:
//data_type = FdoDataType_CLOB;
data_type = FdoDataType_String;
break;
default:
return; //其他可能类型字段暂不转换
}
m_logicalProperty->SetDataType(data_type);
// 如果是字符串类型设置长度
if (data_type == FdoDataType_String)
{
if(fieldInfo->m_nType == UGC::UGFieldInfo::NVarChar)
m_logicalProperty->SetLength(fieldInfo->m_nSize * 2);
else
m_logicalProperty->SetLength(fieldInfo->m_nSize);
}
// 如果是十进制类型设置位数和精度
if (data_type == FdoDataType_Decimal)
{
m_logicalProperty->SetPrecision(fieldInfo->m_nPrecision);
m_logicalProperty->SetScale(fieldInfo->m_nScale);
}
FdoPtr<FdoClassDefinition> logicalClass = m_parentLpClass->GetLogicalClass(); //各种逻辑属性要加入此类中
FdoPtr<FdoPropertyDefinitionCollection> logicalProperties = logicalClass->GetProperties();
// 如果有重复字段名返回
if (logicalProperties->Contains (m_logicalProperty->GetName ()))
return;
// modified by zhouxu 2007-12-18
// 对Sm开头的字段除了SmUserId以外都设为只读。/ 并且加为逻辑类的标识属性
if((0 == wcscmp (L"SmGeometry", pLogicalPropertyName))
|| (0 == wcscmp(L"SMGEOMETRY",pLogicalPropertyName))) //modified by zhouxu 2007-12-7 //added by majun ,要素类中去掉SmGeometry字段
{
return;
}
else if((0 == wcscmp(L"SmUserID", pLogicalPropertyName))
|| (0 == wcscmp(L"SMUSERID", pLogicalPropertyName)))
{
m_logicalProperty->SetReadOnly(false);
m_logicalProperty->SetIsAutoGenerated(false);
m_logicalProperty->SetNullable(false);
logicalProperties->Add(m_logicalProperty);
}
else if((0 == wcscmp(L"Sm", pLogicalPropertyName.Mid(0,2)))
|| (0 == wcscmp(L"SM", pLogicalPropertyName.Mid(0,2))))
{
m_logicalProperty->SetReadOnly(true);//m_logicalProperty->SetReadOnly(true);
m_logicalProperty->SetIsAutoGenerated(true);
m_logicalProperty->SetNullable(false);
//// 作为一个标识属性
//FdoPtr<FdoDataPropertyDefinitionCollection> pIdentityProperties = logicalClass->GetIdentityProperties();
//VALIDATE_POINTER(pIdentityProperties);
logicalProperties->Add(m_logicalProperty);
//pIdentityProperties->Add(m_logicalProperty);
}
else
{
m_logicalProperty->SetReadOnly(false);
m_logicalProperty->SetIsAutoGenerated(false);
m_logicalProperty->SetNullable(true);
logicalProperties->Add(m_logicalProperty);
}
}
/* Test all data types update operation. */
void BasicUpdateTests::full_update ()
{
int iRow = 0;
FdoPtr<FdoPropertyValueCollection> values;
FdoPtr<FdoISelect> selectCmd;
FdoPtr<FdoIFeatureReader> reader;
if (CreateSchemaOnly()) return;
try
{
mConnection = ArcSDETests::GetConnection ();
mConnection->SetConnectionString (ArcSDETestConfig::ConnStringMetadcovSingleDb());
mConnection->Open ();
// Clean up previous tests:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
// Insert 2 rows of data:
while (iRow<=1)
{
FdoPtr<FdoIInsert> insert = (FdoIInsert*)mConnection->CreateCommand (FdoCommandType_Insert);
insert->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex()); // misnomer, it's not a feature class
values = insert->GetPropertyValues ();
for (int i = 0; i < PropertyCount; i++)
{
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create ();
value->SetName (Data[i]->mPropertyName);
FdoPtr<FdoValueExpression> expression = (FdoValueExpression*)ArcSDETests::ParseByDataType (Data[i]->mPropertyData[iRow], Data[i]->mPropertyType);
value->SetValue (expression);
values->Add (value);
}
reader = insert->Execute ();
// none returned: reader->Close ();
iRow++;
}
// check by doing a select
selectCmd = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
selectCmd->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
reader = selectCmd->Execute ();
FdoInt32 iSelectedRow = 0;
while (reader->ReadNext ())
{
// NOTE: we're assuming we receive the rows in the same order we inserted them
for (int i = 0; i < PropertyCount; i++)
checkEqual(reader, Data[i]->mPropertyName, Data[i]->mPropertyType, Data[i]->mPropertyData[iSelectedRow]);
iSelectedRow++;
}
reader->Close ();
// Update both rows, providing several values in the *reverse* order as class properties appear:
FdoPtr<FdoIUpdate> update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex()); // misnomer, it's not a feature class
wchar_t filter[1024];
wcscpy (filter, Data[3]->mPropertyName);
wcscat (filter, L" = ");
wcscat (filter, Data[3]->mPropertyData[0]);
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
values = update->GetPropertyValues ();
for (int iPropertyIndex = 0; iPropertyIndex < PropertyCount; iPropertyIndex++)
{
int iDataIndex = (PropertyCount - 1) - iPropertyIndex;
FdoPtr<FdoValueExpression> expression;
expression = (FdoValueExpression*)ArcSDETests::ParseByDataType (Data[iDataIndex]->mPropertyData[iRow], Data[iDataIndex]->mPropertyType);
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create (Data[iDataIndex]->mPropertyName, expression);
values->Add (value);
}
FdoInt32 iUpdatedRows = update->Execute ();
//NOTE: iUpdatedRows is currently always 1, regardless of the # of rows actually affected.
// check by doing a select
selectCmd = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
selectCmd->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
reader = selectCmd->Execute ();
while (reader->ReadNext ())
for (int i = 0; i < PropertyCount; i++)
checkEqual(reader, Data[i]->mPropertyName, Data[i]->mPropertyType, Data[i]->mPropertyData[iRow]);
reader->Close ();
iRow++;
// Update both rows, providing *mostly NULL value* in the *same* order as class properties appear:
update = (FdoIUpdate*)mConnection->CreateCommand (FdoCommandType_Update);
update->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex()); // misnomer, it's not a feature class
wcscpy (filter, Data[3]->mPropertyName);
wcscat (filter, L" = ");
wcscat (filter, Data[3]->mPropertyData[iRow-1]);
update->SetFilter (FdoPtr<FdoFilter>(FdoFilter::Parse (filter)));
values = update->GetPropertyValues ();
for (int i = 0; i < PropertyCount; i++)
{
FdoPtr<FdoValueExpression> expression;
expression = (FdoValueExpression*)ArcSDETests::ParseByDataType (Data[i]->mPropertyData[iRow], Data[i]->mPropertyType);
FdoPtr<FdoPropertyValue> value = FdoPropertyValue::Create (Data[i]->mPropertyName, expression);
value->SetValue (expression);
values->Add (value);
}
iUpdatedRows = update->Execute ();
//NOTE: iUpdatedRows is currently always 1, regardless of the # of rows actually affected.
// check by doing a select
selectCmd = (FdoISelect*)mConnection->CreateCommand (FdoCommandType_Select);
selectCmd->SetFeatureClassName (ArcSDETestConfig::QClassNameTestClassComplex());
reader = selectCmd->Execute ();
while (reader->ReadNext ())
for (int i = 0; i < PropertyCount; i++)
checkEqual(reader, Data[i]->mPropertyName, Data[i]->mPropertyType, Data[i]->mPropertyData[iRow]);
reader->Close ();
// Clean up after test:
CleanUpClass(mConnection, ArcSDETestConfig::ClassSchemaTestClassComplex(), ArcSDETestConfig::ClassNameTestClassComplex(), true);
}
catch (FdoException* ge)
{
fail (ge);
}
}