public ReferencingTableInfo([NotNull] ITable table,
[NotNull] string relation,
[CanBeNull] string whereClause)
{
Table = GetQueryTable(table, relation, out _foreignKeyFieldName);
Filter = new QueryFilterClass {
WhereClause = whereClause
};
_foreignKeyFieldIndex = Table.FindField(_foreignKeyFieldName);
ForeignKeyFieldType =
KeySetUtils.GetFieldValueType(Table, _foreignKeyFieldIndex);
}
private void EnsureReferenceInfos()
{
if (_referencingTableInfos != null)
{
return;
}
_referencedTableInfo = new ReferencedTableInfo(_referencedTable,
_referencedTableKey);
_referencingTableInfos = new List <ReferencingTableInfo>();
for (var i = 0; i < _referencingTables.Count; i++)
{
ITable referencingTable = _referencingTables[i];
int referencingTableIndex = i + 1; // first index is referenced table
string whereClause = GetConstraint(referencingTableIndex);
string relation = _relations[i];
var referencingTableInfo = new ReferencingTableInfo(
referencingTable, relation, whereClause);
bool supported =
KeySetUtils.IsSupportedTypeCombination(
_referencedTableInfo.KeyFieldType,
referencingTableInfo.ForeignKeyFieldType);
Assert.ArgumentCondition(
supported,
"key fields have unsupported combination of types: " +
"referencing table = {0}, foreign key = {1}, referenced key = {2}",
((IDataset)referencingTableInfo.Table).Name,
referencingTableInfo.ForeignKeyFieldType,
_referencedTableInfo.KeyFieldType);
_referencingTableInfos.Add(referencingTableInfo);
}
_referencedTableFilter = new QueryFilterClass
{
WhereClause = GetConstraint(0)
};
GdbQueryUtils.SetSubFields(_referencedTableFilter,
_referencedTableInfo.KeyFieldName,
_referencedTable.OIDFieldName);
}
public ReferencedTableInfo([NotNull] ITable keyTable,
[NotNull] string keyFieldName)
{
Table = keyTable;
KeyFieldName = keyFieldName;
KeyFieldIndex = keyTable.FindField(keyFieldName);
const string format = "'field '{0}' not found in table '{1}'";
Assert.ArgumentCondition(KeyFieldIndex >= 0,
format, keyFieldName,
DatasetUtils.GetName(keyTable));
KeyFieldType = KeySetUtils.GetFieldValueType(keyTable, KeyFieldIndex);
KeySet = KeySetUtils.CreateKeySet(KeyFieldType);
}
private static void GetFieldInformation(
[NotNull] ITable table,
[NotNull] ITable referencedTable,
[NotNull] IList <string> fkFields,
[NotNull] IList <string> pkFields,
[NotNull] out List <int> foreignKeyFieldIndices,
[NotNull] out List <int> referencedKeyFieldIndices,
[NotNull] out List <esriFieldType> foreignKeyFieldTypes,
[NotNull] out List <esriFieldType> referencedKeyFieldTypes)
{
foreignKeyFieldIndices = new List <int>();
referencedKeyFieldIndices = new List <int>();
foreignKeyFieldTypes = new List <esriFieldType>();
referencedKeyFieldTypes = new List <esriFieldType>();
for (int i = 0; i < fkFields.Count; i++)
{
string fkField = fkFields[i];
string pkField = pkFields[i];
int fkIndex = table.FindField(fkField);
int pkIndex = referencedTable.FindField(pkField);
const string format = "'field '{0}' not found in table '{1}'";
Assert.ArgumentCondition(fkIndex >= 0, format,
fkField, DatasetUtils.GetName(table));
Assert.ArgumentCondition(pkIndex >= 0, format,
pkField, DatasetUtils.GetName(referencedTable));
esriFieldType fkType = KeySetUtils.GetFieldValueType(table, fkIndex);
esriFieldType pkType = KeySetUtils.GetFieldValueType(referencedTable, pkIndex);
bool supported = KeySetUtils.IsSupportedTypeCombination(fkType, pkType);
Assert.ArgumentCondition(supported,
"key fields have unsupported combination of types: " +
"foreign key {0}: {1} - referenced key {2}: {3}",
fkField, fkType, pkField, pkType);
foreignKeyFieldIndices.Add(fkIndex);
referencedKeyFieldIndices.Add(pkIndex);
foreignKeyFieldTypes.Add(fkType);
referencedKeyFieldTypes.Add(pkType);
}
}
private void EnsureKeySet()
{
if (_keySet != null || _tupleKeySet != null)
{
return;
}
_whereClause = GetConstraint(_referencedTable);
if (_usesSingleKey)
{
_keySet = KeySetUtils.ReadKeySet(_referencedTable, _referencedKeyFields[0],
_whereClause, _referencedKeyFieldTypes[0],
_referencedKeyFieldIndices[0]);
}
else
{
_tupleKeySet = KeySetUtils.ReadTupleKeySet(_referencedTable, _referencedKeyFields,
_whereClause, _referencedKeyFieldTypes,
_referencedKeyFieldIndices);
}
}
