public ITable OpenQueryTable(string relationshipClassName,
Model model,
IList <ITable> tables,
JoinType joinType,
string whereClause)
{
if (_dataRequestFunc != null)
{
return(GetRemoteQueryTable(relationshipClassName, model, tables, joinType,
whereClause));
}
// If schema was cached locally (no link back) - Only used by unit test
if (_virtualWorkspaces != null)
{
GdbWorkspace workspace =
_virtualWorkspaces.FirstOrDefault(w => w.WorkspaceHandle == model.Id);
if (workspace == null)
{
throw new InvalidOperationException($"Workspace for model {model} not found");
}
return(workspace.OpenQueryTable(relationshipClassName));
}
throw new NotImplementedException();
}
private static IWorkspaceContext GetWorkspaceContext(
DdxModel model, GdbWorkspace gdbWorkspace)
{
return(new SimpleWorkspaceContext(
model, gdbWorkspace,
GetWorkspaceDatasets(model, gdbWorkspace),
new List <WorkspaceAssociation>()));
}
private void SetGdbSchema(IList <GdbWorkspace> gdbWorkspaces)
{
_virtualWorkspaces = gdbWorkspaces;
GdbWorkspace primaryWorkspace =
gdbWorkspaces.First(w => w.WorkspaceHandle == _primaryModel.Id);
PrimaryWorkspaceContext = GetWorkspaceContext(_primaryModel, primaryWorkspace);
}
public string GetRelationshipClassName(string associationName, Model model)
{
GdbWorkspace workspace =
_virtualWorkspaces.FirstOrDefault(w => w.WorkspaceHandle == model.Id);
Assert.NotNull(workspace, "GdbWorkspace for model {0} not available", model);
return(GetRelationshipClassName(workspace, associationName, model));
}
public VirtualModelContext(IList <GdbWorkspace> workspaces,
Model model)
{
_virtualWorkspaces = workspaces;
_primaryModel = model;
GdbWorkspace primaryWorkspace = workspaces[0];
PrimaryWorkspaceContext = GetWorkspaceContext(model, primaryWorkspace);
}
private GdbWorkspace GetWorkspace([NotNull] DdxModel model)
{
// TODO: In case it is needed before InitializeSchema() is called, allow creation of
// a 'lazy' workspace that is just an empty container that gets initialized
// with datasets from remote only when necessary.
GdbWorkspace workspace =
_virtualWorkspaces?.FirstOrDefault(w => w.WorkspaceHandle == model.Id);
return(workspace);
}
public static GdbTableContainer CreateGdbTableContainer(
[NotNull] IEnumerable <ObjectClassMsg> objectClassMessages,
[CanBeNull] Func <DataVerificationResponse, DataVerificationRequest> getRemoteDataFunc,
out GdbWorkspace workspace)
{
GdbTableContainer container = null;
int?workspaceHandle = null;
workspace = null;
foreach (ObjectClassMsg objectClassMsg in objectClassMessages)
{
if (workspaceHandle == null)
{
workspaceHandle = objectClassMsg.WorkspaceHandle;
container = new GdbTableContainer();
workspace = new GdbWorkspace(container)
{
WorkspaceHandle = objectClassMsg.WorkspaceHandle
};
}
else
{
Assert.AreEqual(workspaceHandle, objectClassMsg.WorkspaceHandle,
"Not all features are from the same workspace");
}
if (objectClassMsg.WorkspaceHandle == -1)
{
workspace = null;
}
Func <ITable, BackingDataset> createBackingDataset = null;
if (getRemoteDataFunc != null)
{
createBackingDataset = (t) =>
new RemoteDataset(t, getRemoteDataFunc,
new ClassDef
{
ClassHandle = objectClassMsg.ClassHandle,
WorkspaceHandle = objectClassMsg.WorkspaceHandle
});
}
GdbTable gdbTable =
FromObjectClassMsg(objectClassMsg, workspace, createBackingDataset);
container.TryAdd(gdbTable);
}
return(container);
}
private static IEnumerable <WorkspaceDataset> GetWorkspaceDatasets(
DdxModel model, GdbWorkspace primaryWorkspace)
{
foreach (IDataset gdbDataset in primaryWorkspace.GetDatasets())
{
Dataset modelDataset = model.GetDatasetByModelName(gdbDataset.Name);
if (modelDataset != null)
{
yield return(new WorkspaceDataset(gdbDataset.Name, null, modelDataset));
}
}
}
private ITable GetRemoteQueryTable([NotNull] string relationshipClassName,
[NotNull] Model model,
[NotNull] IList <ITable> tables,
JoinType joinType,
[CanBeNull] string whereClause)
{
var dataRequest = new DataVerificationResponse
{
SchemaRequest = new SchemaRequest()
};
RelationshipClassQuery relClassQueryMsg =
new RelationshipClassQuery
{
RelationshipClassName = relationshipClassName,
WorkspaceHandle = model.Id,
JoinType = (int)joinType,
};
relClassQueryMsg.Tables.AddRange(tables.Select(DatasetUtils.GetName));
if (!string.IsNullOrEmpty(whereClause))
{
relClassQueryMsg.WhereClause = whereClause;
}
dataRequest.SchemaRequest.RelationshipClassQueries.Add(relClassQueryMsg);
DataVerificationRequest dataResponse = _dataRequestFunc(dataRequest);
GdbWorkspace gdbWorkspace =
Assert.NotNull(_virtualWorkspaces).First(w => w.WorkspaceHandle == model.Id);
ObjectClassMsg queryTableMsg = dataResponse.Schema.RelclassDefinitions.First();
Func <ITable, BackingDataset> createBackingDataset = null;
if (_dataRequestFunc != null)
{
createBackingDataset = (t) =>
new RemoteDataset(t, _dataRequestFunc, null, relClassQueryMsg);
}
// It is cached on the client side, in case various tests utilize the same definition.
// TODO: Test!
return(ProtobufConversionUtils.FromObjectClassMsg(queryTableMsg, gdbWorkspace,
createBackingDataset));
}
public IWorkspaceContext GetWorkspaceContext(IDdxDataset dataset)
{
GdbWorkspace gdbWorkspace = GetWorkspace(dataset.Model);
return(GetWorkspaceContext(dataset.Model, gdbWorkspace));
}
public ITable OpenTable(IObjectDataset dataset)
{
GdbWorkspace workspace = GetWorkspace(dataset.Model);
return(workspace?.OpenTable(dataset.Name));
}
public IFeatureClass OpenFeatureClass(IVectorDataset dataset)
{
GdbWorkspace workspace = GetWorkspace(dataset.Model);
return(workspace?.OpenFeatureClass(dataset.Name));
}
