void GwsBinaryFeatureWriter::WriteAssociationProperty(FdoAssociationPropertyDefinition* apd,
FdoIFeatureReader* reader)
{
if( apd->GetIsReadOnly() )
return;
FdoPtr<FdoDataPropertyDefinitionCollection> idents = apd->GetIdentityProperties();
if( idents->GetCount() == 0 )
{
// Search for property values with names build from the association property name and the
// associated class identity properties. For example if the associated class identifier is "Id" and the
// association property name is "AssocProp", then we should search for a property value with
// name: "AssocProp.Id". If that property value is found and set, then that means an association
// exists between the new object(we are about to insert) and the object identified by the value
// of the property value(AssocProp.Id)
FdoPtr<FdoClassDefinition> cls = apd->GetAssociatedClass();
idents = cls->GetIdentityProperties();
}
if( reader->IsNull( apd->GetName() ) )
return;
FdoPtr<FdoIFeatureReader> loc_reader = reader->GetFeatureObject( apd->GetName() );
if( ! loc_reader->ReadNext() )
return;
for(int i=0; i<idents->GetCount(); i++ )
{
FdoPtr<FdoDataPropertyDefinition> prop = idents->GetItem( i );
if( ! loc_reader->IsNull( prop->GetName() ) )
WriteProperty( prop, loc_reader);
}
}
const void* FdoRdbmsSQLDataReader::GetGeometry(FdoInt32 index, FdoInt32* len, bool noExcOnInvalid)
{
ValidateIndex(index);
if( ! mHasMoreRows )
throw FdoCommandException::Create(NlsMsgGet(FDORDBMS_62, noMoreRows));
if (mGeomIdx != index)
{
FdoIGeometry* geom = NULL;
bool isSupportedType = false;
bool isNull = false;
mGeomIdx = index;
if (mWkbBuffer)
*mWkbBuffer = 0;
mQueryResult->GetBinaryValue (index+1, sizeof(FdoIGeometry *), (char*)&geom, &isNull, NULL);
if ( !isNull && geom && geom->GetDerivedType() != FdoGeometryType_None )
isSupportedType = true;
if ( !isNull && geom != NULL )
{
if ( isSupportedType )
{
FdoPtr<FdoFgfGeometryFactory> gf = FdoFgfGeometryFactory::GetInstance();
FdoPtr<FdoByteArray> fgf = gf->GetFgf(geom);
if (fgf != NULL && fgf->GetCount() != 0)
{
mWkbGeomLen = fgf->GetCount();
if (mWkbBufferLen < mWkbGeomLen)
{
delete[] mWkbBuffer;
mWkbBufferLen = mWkbGeomLen;
mWkbBuffer = new unsigned char[mWkbGeomLen];
}
memcpy(mWkbBuffer, fgf->GetData(), mWkbGeomLen);
}
else
mWkbGeomLen = 0;
}
else
mWkbGeomLen = -1;
}
else // isNull indicator is not set by dbi_get_val_b for geometry columns
mWkbGeomLen = 0;
}
*len = mWkbGeomLen;
if (*len <= 0)
{
if (noExcOnInvalid)
return NULL;
else if (*len == 0)
throw FdoCommandException::Create(NlsMsgGet1( FDORDBMS_385, "Property '%1$ls' value is NULL; use IsNull method before trying to access the property value", mColList[index].column ));
else
throw FdoCommandException::Create( NlsMsgGet(FDORDBMS_116, "Unsupported geometry type" ) );
}
return mWkbBuffer;
}
bool GwsBinaryFeatureWriter::WriteAssociationProperty(FdoAssociationPropertyDefinition* apd,
FdoPropertyValueCollection* pvc)
{
bool errorIfSet = apd->GetIsReadOnly();
bool oneIdentIsNull = false;
bool written = false;
FdoPtr<FdoDataPropertyDefinitionCollection> idents = apd->GetIdentityProperties();
if( idents->GetCount() == 0 )
{
// Search for property values with names build from the association property name and the
// associated class identity properties. For example if the associated class identifier is "Id" and the
// association property name is "AssocProp", then we should search for a property value with
// name: "AssocProp.Id". If that property value is found and set, then that means an association
// exists between the new object(we are about to insert) and the object identified by the value
// of the property value(AssocProp.Id)
FdoPtr<FdoClassDefinition> cls = apd->GetAssociatedClass();
idents = cls->GetIdentityProperties();
}
for(int i=0; i<idents->GetCount(); i++ )
{
FdoPtr<FdoDataPropertyDefinition> prop = idents->GetItem( i );
std::wstring wstr = apd->GetName();
wstr += L".";
wstr += prop->GetName();
FdoPtr<FdoPropertyValue> pv = pvc->FindItem( wstr.c_str() );
if(pv != NULL)
{
if( errorIfSet )
GWS_THROW(eGwsFailed); //cannot add readonly association property value
if( oneIdentIsNull )
GWS_THROW(eGwsFailed); //one of the identity properties is null
WriteProperty(prop, pv, true);
written = true;
oneIdentIsNull = false;
}
else
{
if( written ) // we already written one or more identity and this one is null
GWS_THROW(eGwsFailed);
oneIdentIsNull = true;
}
}
return written;
}
//
// The TRIM function requires special processing.
void FdoRdbmsMySqlFilterProcessor::ProcessTrimFunction( FdoFunction& expr)
{
// Append the function name and the opening bracket.
ProcessFunctionName(expr);
AppendString( "( " );
// Process the arguments. This is were the special processing is required.
// If the call includes an operator (BOTH, LEADING, TRAILING), it is required
// to add a FROM clause after the operation keyword.
FdoPtr<FdoExpressionCollection> exprCol = expr.GetArguments();
for ( int i=0; i<exprCol->GetCount(); i++ )
{
FdoPtr<FdoExpression>exp = exprCol->GetItem( i );
if ( (i == 0) && (IsDataValue( exp )) )
{
FdoDataValue *dataValue = (static_cast<FdoDataValue *>(exp.p) );
if ( dataValue->GetDataType() == FdoDataType_String )
{
FdoStringValue *stringValue = static_cast<FdoStringValue *>(dataValue);
AppendString( stringValue->GetString() );
AppendString( " FROM " );
}
else
throw FdoFilterException::Create(NlsMsgGet(FDORDBMS_29, "Unsupported FDO type in expression"));
}
else
HandleExpr( exp );
}
AppendString( " )" );
}
void CGwsQueryResultDescriptors::appendPropertyNames (
FdoIdentifierCollection * propnamestoadd,
FdoClassDefinition * classDef,
FdoStringCollection * propnames,
std::vector<CGwsPropertyDesc> & propdsc
)
{
FdoPtr<FdoPropertyDefinitionCollection> properties;
FdoPtr<FdoClassDefinition> baseClass = classDef->GetBaseClass ();
if (baseClass != NULL) {
appendPropertyNames (propnamestoadd, baseClass, propnames, propdsc);
}
properties = classDef->GetProperties ();
if (properties == NULL)
return;
for (int i = 0; i < properties->GetCount (); i ++) {
FdoPtr<FdoPropertyDefinition> pFdoProperty = properties->GetItem (i);
if (propnamestoadd == NULL ||
propnamestoadd->IndexOf (pFdoProperty->GetName ()) >= 0)
pushPropDefinition (pFdoProperty, propnames,propdsc);
}
}
MgReader* MgSelectCommand::ExecuteJoined(MgStringCollection* idPropNames, bool bForceOneToOne)
{
Ptr<MgReader> ret;
MG_FEATURE_SERVICE_TRY()
#ifdef DEBUG_FDO_JOIN
FdoPtr<FdoIdentifierCollection> cmdPropNames = m_command->GetPropertyNames();
for (FdoInt32 i = 0; i < cmdPropNames->GetCount(); i++)
{
FdoPtr<FdoIdentifier> ident = cmdPropNames->GetItem(i);
STRING idStr = ident->ToString();
ACE_DEBUG((LM_INFO, ACE_TEXT("\n(%t) [FdoISelect]: (%W)"), idStr.c_str()));
}
#endif
FdoPtr<FdoIFeatureReader> fdoReader = m_command->Execute();
if (bForceOneToOne)
{
FdoPtr<FdoStringCollection> names = MgServerFeatureUtil::MgToFdoStringCollection(idPropNames, false);
FdoPtr<FdoIFeatureReader> forcedReader = new MgFdoForcedOneToOneFeatureReader(fdoReader, names);
ret = new MgServerFeatureReader(m_connection, forcedReader, idPropNames);
}
else
{
ret = new MgServerFeatureReader(m_connection, fdoReader, idPropNames);
}
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgSelectCommand.ExecuteJoined")
return ret.Detach();
}
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);
}
EGwsStatus GwsCommonFdoUtils::DescribeClassSC (
FdoIConnection * conn,
const GWSQualifiedName & classname,
GwsSpatialContextDescription & desc
)
{
FdoPtr<FdoFeatureSchema> schema;
FdoPtr<FdoClassDefinition> classDef;
GwsCommonFdoUtils::GetClassDefinition (conn, classname, schema.p, classDef.p);
for (; classDef != NULL ; classDef = classDef->GetBaseClass ()) {
FdoPtr<FdoPropertyDefinitionCollection> propdsc = classDef->GetProperties ();
// discover geometric property name. Use the first one if there are many.
for (int idx = 0; idx < propdsc->GetCount(); idx ++) {
FdoPtr<FdoPropertyDefinition> prop;
prop = propdsc->GetItem (idx);
if (prop->GetPropertyType () == FdoPropertyType_GeometricProperty) {
FdoGeometricPropertyDefinition* geomProp = static_cast<FdoGeometricPropertyDefinition*>(prop.p);
FdoString* pSC = geomProp->GetSpatialContextAssociation();
if(pSC != NULL) {
return GwsCommonFdoUtils::DescribeSC (conn, pSC, desc);
}
}
}
}
return eGwsSCNotFound;
}
GWSExtendedFeatureId GwsCommonFdoUtils::MakeFeatureId (
const GWSQualifiedName & classname,
FdoPtr<FdoPropertyValueCollection> ident,
const wchar_t * ltname
)
{
static_cast<void>(&(ltname)); // For "unreferenced formal parameter" warning
static GWSExtendedFeatureId s_fid;
try {
CGwsDataValueCollection * keyvals = NULL;
keyvals = (CGwsDataValueCollection *) CGwsDataValueCollection::Create ();
int size = ident->GetCount ();
for (int i = 0; i < size ; i++) {
FdoPtr<FdoPropertyValue> propval;
FdoPtr<FdoDataValue> value;
propval = ident->GetItem (i);
value = (FdoDataValue *) propval->GetValue ();
keyvals->Add (value);
}
return GWSExtendedFeatureId (classname, keyvals);
} catch (FdoException * e) {
assert (false);
e->Release ();
}
return s_fid;
}
// Returns an FDO expression engine configured with the custom functions
// defined by stylization.
FdoExpressionEngine* ExpressionHelper::GetExpressionEngine(Renderer* renderer, RS_FeatureReader* reader)
{
// get the user-defined functions
FdoPtr<FdoExpressionEngineFunctionCollection> userDefinedFunctions = ExpressionHelper::GetExpressionEngineFunctions(renderer, reader);
// create the engine
FdoPtr<FdoIFeatureReader> fdoReader = reader? reader->GetInternalReader() : NULL;
FdoPtr<FdoClassDefinition> classDef = fdoReader? fdoReader->GetClassDefinition() : FdoClass::Create();
FdoExpressionEngine* exec = FdoExpressionEngine::Create(fdoReader, classDef, userDefinedFunctions);
// now that we have the engine, set it on the functions that need it - for now
// this is only the IF function
for (int i=0; i<userDefinedFunctions->GetCount(); ++i)
{
FdoPtr<FdoExpressionEngineIFunction> func = userDefinedFunctions->GetItem(i);
ExpressionFunctionIf* funcIf = dynamic_cast<ExpressionFunctionIf*>(func.p);
if (funcIf)
{
funcIf->SetExpressionEngine(exec);
break;
}
}
return exec;
}
const FdoByte * FdoXmlFeatureReaderImpl::GetGeometry(FdoString* propertyName, FdoInt32 * count)
{
FdoByte* data = NULL;
FdoPtr<FdoByteArray> ba = this->GetGeometry(propertyName);
if (NULL != ba.p)
{
data = ba->GetData();
*count = ba->GetCount();
}
return data;
}
int CGwsQueryResultDescriptors::Contains (FdoString* propertyName)
{
FdoPtr<FdoStringCollection> pPropNames = PropertyNames();
for(int i=0;i<pPropNames->GetCount();i++)
{
FdoString* pComp = pPropNames->GetString(i);
if( _wcsicmp( propertyName, pComp ) == 0)
return i;
}
return -1;
}
/// <summary>Gets the geometry value of the specified property as a byte array in
/// FGF format. Because no conversion is performed, the property must be
/// of Geometric type; otherwise, an exception is thrown.
/// This method is a language-specific performance optimization that returns a
/// pointer to the array data, rather than to an object that encapsulates
/// the array. The array's memory area is only guaranteed to be valid
/// until a call to ReadNext() or Close(), or the disposal of this reader
/// object.</summary>
/// <param name="identifier">Input the property name.</param>
/// <param name="count">Output the number of bytes in the array.</param>
/// <returns>Returns a pointer to the byte array in FGF format.</returns>
const FdoByte* SuperMapFeatureReader::GetGeometry (FdoString* identifier, FdoInt32 * count)
{
FdoPtr<FdoByteArray> byteArray = GetGeometry (identifier);
if(NULL == byteArray)
{
return NULL;
}
FdoByte *ret = byteArray->GetData();
*count = byteArray->GetCount();
return ret;
}
void MgFeatureNumericFunctions::Initialize(MgReader* reader, FdoFunction* customFunction, CREFSTRING propertyAlias)
{
CHECKNULL((MgReader*)reader, L"MgFeatureNumericFunctions.Initialize");
CHECKNULL((FdoFunction*)customFunction, L"MgFeatureNumericFunctions.Initialize");
if(1 == reader->GetPropertyCount())
{
m_type = MgServerFeatureUtil::GetPropertyDefinition(reader, m_propertyName);
}
else
{
// Only get the property needed
FdoPtr<FdoExpressionCollection> exprCol = customFunction->GetArguments();
FdoInt32 cnt = exprCol->GetCount();
FdoPtr<FdoExpression> expr;
if(cnt == 1)
{
expr = exprCol->GetItem(0);
FdoIdentifier* propName = dynamic_cast<FdoIdentifier*>(expr.p);
CHECKNULL(propName, L"MgFeatureNumericFunctions.Initialize");
m_propertyName = propName->GetName();
m_type = reader->GetPropertyType(m_propertyName);
}
else
{
// Throw original exception
m_type = MgServerFeatureUtil::GetPropertyDefinition(reader, m_propertyName);
}
}
// TODO: Should we really check this, may be we can ignore ??
// because we can only come to here if property type is numeric
this->CheckSupportedPropertyType();
// We must have an property alias
// Though we can name a property with same name as function expression
// But Fdo forces to have an alias. Therefore we implement this restriction.
if (propertyAlias.empty())
{
STRING message = MgServerFeatureUtil::GetMessage(L"MgMissingPropertyAlias");
MgStringCollection arguments;
arguments.Add(message);
throw new MgFeatureServiceException(L"MgFeatureDistribution.Initialize", __LINE__, __WFILE__, &arguments, L"", NULL);
}
m_reader = SAFE_ADDREF(reader);
m_customFunction = FDO_SAFE_ADDREF(customFunction);
m_propertyAlias = propertyAlias;
}
FdoDataPropertyDefinitionCollection* GwsBinaryFeatureWriter::FindIDProps(FdoClassDefinition* fc)
{
FdoPtr <FdoDataPropertyDefinitionCollection> idpdc = fc->GetIdentityProperties();
FdoPtr<FdoClassDefinition> base = FDO_SAFE_ADDREF(fc);
//go up class hierarchy to find base class (it has the identity properties)
while ((base = base->GetBaseClass()) != NULL)
idpdc = base->GetIdentityProperties();
if (idpdc->GetCount() == 0)
return NULL;
return (FDO_SAFE_ADDREF (idpdc.p));
}
void SuperMapConnection::Flush()
{
TRACE(_T("调用 SuperMapConnection::Flush ...\n"));
FdoPtr<SuperMapLpFeatureSchemaCollection> schemas = GetLpSchemas();
int count = schemas->GetCount();
for(int i = 0; i < count; ++i)
{
FdoPtr<SuperMapLpFeatureSchema> lpSchema = schemas->GetItem(i);
FdoPtr<SuperMapLpClassDefinitionCollection> classes = lpSchema->GetLpClasses();
int class_count = classes->GetCount();
for(int j = 0; j < class_count; ++j)
{
FdoPtr<SuperMapLpClassDefinition> lpClass = classes->GetItem(j);
UGC::UGDataset* pDataset = lpClass->GetDataset();
//以同样的方式打开该数据集以使其更新
pDataset->Open();
}
}
}
FdoStringCollection * CGwsPreparedFeatureQuery::GetOrderBy ()
{
FdoPtr<FdoIdentifierCollection> ordering = ((FdoISelect *) m_pCommand.p)->GetOrdering ();
FdoStringCollection * orderBy = NULL;
if(NULL == ordering) return NULL;
for (int i = 0; i < ordering->GetCount (); i ++) {
FdoPtr<FdoIdentifier> ident = ordering->GetItem (i);
if (orderBy == NULL) {
orderBy = FdoStringCollection::Create ();
}
orderBy->Add (ident->GetText ());
}
return orderBy;
}
MgByteReader* MgdSqlDataReader::GetGeometry(CREFSTRING propertyName)
{
Ptr<MgByteReader> geom;
MG_FEATURE_SERVICE_TRY()
FdoPtr<FdoByteArray> byteArray = m_reader->GetGeometry(propertyName.c_str());
INT32 len = (INT32)byteArray->GetCount();
const FdoByte* data = byteArray->GetData();
if (data != NULL)
{
Ptr<MgByte> mgBytes = new MgByte((BYTE_ARRAY_IN)data, len);
Ptr<MgByteSource> bSource = new MgByteSource(mgBytes);
bSource->SetMimeType(MgMimeType::Agf);
geom = bSource->GetReader();
}
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgdSqlDataReader::GetGeometry")
return geom.Detach();
}
MgByteReader* MgdSqlDataReader::GetCLOB(CREFSTRING propertyName)
{
Ptr<MgByteReader> clob;
MG_FEATURE_SERVICE_TRY()
FdoPtr<FdoLOBValue> fdoVal = m_reader->GetLOB(propertyName.c_str());
if (fdoVal != NULL)
{
FdoPtr<FdoByteArray> byteArray = fdoVal->GetData();
if (byteArray != NULL)
{
FdoByte* bytes = byteArray->GetData();
FdoInt32 len = byteArray->GetCount();
Ptr<MgByteSource> byteSource = new MgByteSource((BYTE_ARRAY_IN)bytes,(INT32)len);
clob = byteSource->GetReader();
}
}
MG_FEATURE_SERVICE_CATCH_AND_THROW(L"MgdSqlDataReader::GetCLOB")
return clob.Detach();
}
FdoXmlLpSchemaCollection* FdoXmlSchemaManager::_schemas() {
if (m_lpSchemas == NULL) {
m_lpSchemas = FdoXmlLpSchemaCollection::Create(this);
FdoInt32 count = m_fdoSchemas->GetCount();
FdoPtr<FdoPhysicalSchemaMappingCollection> mappings = m_flags->GetSchemaMappings();
if ( mappings == NULL )
mappings = m_fdoSchemas->GetXmlSchemaMappings();
FdoInt32 count1 = mappings->GetCount();
FdoPtr<FdoXmlSchemaMapping> tempXmlMapping = FdoXmlSchemaMapping::Create(L"temp");
for (int i = 0; i < count; i++) {
FdoPtr<FdoFeatureSchema> schema = m_fdoSchemas->GetItem(i);
FdoPtr<FdoXmlSchemaMapping> mapping = static_cast<FdoXmlSchemaMapping*>(mappings->GetItem(tempXmlMapping->GetProvider(), schema->GetName()));
FdoPtr<FdoXmlLpSchema> lpSchema = FdoXmlLpSchema::Create(schema, mapping);
m_lpSchemas->Add(lpSchema);
}
}
return m_lpSchemas.p;
}
void FdoRdbmsMySqlFilterProcessor::ProcessToInt32Int64Function (FdoFunction& expr)
{
// MySQL uses a different native function name for the expression functions
// TOINT32, TOINT64.
AppendString(MYSQL_FUNCTION_TONUM);
AppendString(OPEN_PARENTH);
FdoPtr<FdoExpressionCollection> exprCol = expr.GetArguments();
for(int i=0; i<exprCol->GetCount(); i++ )
{
if( i!= 0 )
AppendString( L", " );
FdoPtr<FdoExpression>exp = exprCol->GetItem( i );
HandleExpr( exp );
}
// Add the keyword that performs the conversion and the closing bracket.
AppendString( L", SIGNED)" );
}
void FdoRdbmsMySqlFilterProcessor::ProcessCurrentDateFunction (FdoFunction& expr)
{
// MySQL uses a different native function name for the expression function
// CurrentDate.
AppendString(MYSQL_FUNCTION_CURRENTDATE);
AppendString(OPEN_PARENTH);
// Note, that the function does not allow any arguments. However, if some
// are given, they are added to the function call and it is left to MySQL
// to deal with it.
FdoPtr<FdoExpressionCollection> exprCol = expr.GetArguments();
for(int i=0; i<exprCol->GetCount(); i++ )
{
if( i!= 0 )
AppendString( L", " );
FdoPtr<FdoExpression>exp = exprCol->GetItem( i );
HandleExpr( exp );
}
AppendString( CLOSE_PARENTH );
}
bool GwsCommonFdoUtils::GetGeometryName (FdoClassDefinition *pClassDef, std::wstring &name)
{
if(pClassDef == NULL)
return false;
if(pClassDef->GetClassType() == FdoClassType_FeatureClass)
{
FdoFeatureClass* pFeatClass = dynamic_cast<FdoFeatureClass*>(pClassDef);
if(!pFeatClass)
{
assert(false);
return false;
}
FdoPtr<FdoGeometricPropertyDefinition> pgDef = pFeatClass->GetGeometryProperty();
if (pgDef != NULL) {
name = pgDef->GetName();
return true;
}
}
FdoInt32 idx;
FdoPtr<FdoClassDefinition> classDef = pClassDef;
FDO_SAFE_ADDREF(pClassDef);
for (; classDef != NULL ; classDef = classDef->GetBaseClass ())
{
FdoPtr<FdoPropertyDefinitionCollection> propdsc = classDef->GetProperties ();
// discover geometric property name. Use the first one if there are many.
for (idx = 0; idx < propdsc->GetCount(); idx ++) {
FdoPtr<FdoPropertyDefinition> prop;
prop = propdsc->GetItem(idx);
if (prop->GetPropertyType () == FdoPropertyType_GeometricProperty)
{
name = prop->GetName ();
return true;
}
}
}
return false;
}
WSTR GwsCommonFdoUtils::GetRevisionProperty (FdoClassDefinition * classdef)
{
WSTR revision;
// discover revision property. Revision property is defined
// for a given class
FdoPtr<FdoReadOnlyPropertyDefinitionCollection> pBaseProperties = classdef->GetBaseProperties();
// See if property with this name already exists:
for (int idx=0; pBaseProperties != NULL && idx < pBaseProperties->GetCount(); idx++)
{
FdoPtr<FdoPropertyDefinition> pBaseProperty;
pBaseProperty = (FdoPropertyDefinition*)pBaseProperties->GetItem(idx);
if (! _wcsicmp (pBaseProperty->GetName(), REVISIONNUMBER_PROPNAME))
{
revision = pBaseProperty->GetName();
break;
}
}
return revision;
}
MgByteReader* MgdSqlDataReader::GetLOB(CREFSTRING propertyName)
{
Ptr<MgByteReader> byteReader;
try
{
// TODO: We need to switch to FdoIStreamReader when we have streaming capability in MgByteReader
FdoPtr<FdoLOBValue> fdoVal = m_reader->GetLOB(propertyName.c_str());
if (fdoVal != NULL)
{
FdoPtr<FdoByteArray> byteArray = fdoVal->GetData();
if (byteArray != NULL)
{
FdoByte* bytes = byteArray->GetData();
FdoInt32 len = byteArray->GetCount();
Ptr<MgByteSource> byteSource = new MgByteSource((BYTE_ARRAY_IN)bytes,(INT32)len);
// TODO: We need to differentiate between CLOB and BLOB
// TODO: How do we fine the MimeType of data for CLOB
byteSource->SetMimeType(MgMimeType::Binary);
byteReader = byteSource->GetReader();
}
}
}
catch(...)
{
if(m_reader->IsNull(propertyName.c_str()))
{
MgStringCollection arguments;
arguments.Add(propertyName);
throw new MgNullPropertyValueException(L"MgdSqlDataReader::GetLOB",
__LINE__, __WFILE__, &arguments, L"", NULL);
}
else
throw;
}
return byteReader.Detach();
}
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);
}
///<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 ();
}
//
// Aggregate functions require special processing because of the optional
// first parameter. The value of this parameter may be ALL or DISTINCT.
void FdoRdbmsMySqlFilterProcessor::ProcessAggregateFunction (FdoFunction& expr)
{
// Append the function name and the opening bracket.
ProcessFunctionName(expr);
AppendString( "( " );
// Process the arguments. This is were the special processing is required as
// it is required to have the parameters listed sequencially without a comma
// between them.
FdoPtr<FdoExpressionCollection> exprCol = expr.GetArguments();
for (int i=0; i<exprCol->GetCount(); i++)
{
FdoPtr<FdoExpression>exp = exprCol->GetItem(i);
if ((i == 0) && (IsDataValue(exp)))
{
FdoDataValue *dataValue = (static_cast<FdoDataValue *>(exp.p));
if (dataValue->GetDataType() == FdoDataType_String)
{
// Omit ALL if specified as this keyword is not supported in
// MySQL.
FdoStringValue *stringValue = static_cast<FdoStringValue *>(dataValue);
FdoStringP strValue = stringValue->GetString();
if (FdoCommonOSUtil::wcsicmp(strValue, L"ALL") != 0)
{
AppendString(stringValue->GetString());
AppendString(L" ");
}
}
else
throw FdoFilterException::Create(NlsMsgGet(FDORDBMS_29, "Unsupported FDO type in expression"));
}
else
HandleExpr(exp);
}
AppendString(" )");
}
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();
}
MgSpatialContextData* MgServerGetSpatialContexts::GetSpatialContextData(
FdoISpatialContextReader* spatialReader, MgSpatialContextInfo* spatialContextInfo)
{
Ptr<MgSpatialContextData> spatialData = new MgSpatialContextData();
// Name must exist
FdoString* name = spatialReader->GetName();
CHECKNULL((FdoString*)name, L"MgServerGetSpatialContexts.GetSpatialContexts");
spatialData->SetName(STRING(name));
STRING coordSysName = L"";
FdoString* csName = spatialReader->GetCoordinateSystem();
Ptr<MgCoordinateSystemFactory> csFactory;
// WKT for co-ordinate system
FdoString* csWkt = NULL;
STRING srsWkt = L"";
bool haveValidCoordSys = false;
if(NULL != csName && *csName != '\0')
{
coordSysName = STRING(csName);
}
else
{
csWkt = spatialReader->GetCoordinateSystemWkt();
if (csWkt != NULL && *csWkt != '\0')
{
srsWkt = csWkt;
try
{
csFactory = new MgCoordinateSystemFactory();
coordSysName = csFactory->ConvertWktToCoordinateSystemCode(srsWkt);
haveValidCoordSys = (coordSysName.size() != 0);
}
catch (MgException* e)
{
SAFE_RELEASE(e);
}
catch(...)
{
}
}
}
bool spatialContextDefined = !coordSysName.empty();
bool coordSysOverridden = false;
// look for coordinate system override
if (NULL != spatialContextInfo)
{
// Perform substitution of missing coordinate system with
// the spatial context mapping defined in feature source document
MgSpatialContextInfo::const_iterator iter = spatialContextInfo->find(name);
if (spatialContextInfo->end() != iter)
{
csName = (iter->second).c_str();
coordSysOverridden = true;
}
}
if (csName != NULL && *csName != '\0')
{
spatialData->SetCoordinateSystem(STRING(csName));
}
// Desc for spatial context
STRING desc = L"";
// This flag is obsolete and will be deprecated.
bool isActive = spatialReader->IsActive();
if (coordSysOverridden)
{
srsWkt = csName;
desc = MgServerFeatureUtil::GetMessage(L"MgCoordinateSystemOverridden");
}
else if (spatialContextDefined && !coordSysOverridden)
{
// avoid looking one more time after CS in case we have a valid one...
if (!haveValidCoordSys)
{
csWkt = spatialReader->GetCoordinateSystemWkt();
if(NULL != csWkt && *csWkt != '\0')
srsWkt = csWkt;
if (srsWkt.empty())
{
try
{
if (csFactory == NULL)
csFactory = new MgCoordinateSystemFactory();
// Check if the spatial context coordinate system data represents an EPSG
// code. If this is the case the WKT data for the EPSG code has to be
// retrieved.
if (IsEpsgCodeRepresentation(csName))
{
// This is an EPSG code
FdoString* p = NULL;
if ((csName[0] == L'E') || (csName[0] == L'e'))
p = csName+5;
else
p = csName;
INT32 epsgCode = (INT32)wcstol(p, NULL, 10);
// Convert the EPSG numerical code to WKT
srsWkt = csFactory->ConvertEpsgCodeToWkt(epsgCode);
}
else
{
srsWkt = csFactory->ConvertCoordinateSystemCodeToWkt(STRING(csName));
}
}
catch (MgException* e)
{
SAFE_RELEASE(e);
}
catch(...)
{
// Just use the empty WKT.
}
}
}
FdoString* fdoDesc = spatialReader->GetDescription();
if(NULL != fdoDesc)
desc = STRING(fdoDesc);
}
// retrieve other values from spatialReader
FdoSpatialContextExtentType extentType = spatialReader->GetExtentType();
FdoPtr<FdoByteArray> byteArray = spatialReader->GetExtent();
double xyTol = spatialReader->GetXYTolerance();
double zTol = spatialReader->GetZTolerance();
spatialData->SetCoordinateSystemWkt(srsWkt);
spatialData->SetDescription(desc);
spatialData->SetExtentType((INT32)extentType);
if (byteArray.p != NULL)
{
INT32 size = (INT32)byteArray->GetCount();
BYTE_ARRAY_IN bytes = (BYTE_ARRAY_IN)byteArray->GetData();
Ptr<MgByte> extent = new MgByte(bytes, size);
spatialData->SetExtent(extent);
}
// XY Tolerance
spatialData->SetXYTolerance(xyTol);
// Z Tolerance
spatialData->SetZTolerance(zTol);
// This flag is obsolete and will be deprecated.
spatialData->SetActiveStatus(isActive);
return spatialData.Detach();
}