private static void ManageIndexesForUpdate(OID oid, NonNativeObjectInfo nnoi, NonNativeObjectInfo oldMetaRepresentation)
{
// takes the indexes from the oldMetaRepresentation because noi comes
// from the client and is not always
// in sync with the server meta model (In Client Server mode)
var indexes = oldMetaRepresentation.GetClassInfo().GetIndexes();
foreach (var index in indexes)
{
var oldKey = IndexTool.BuildIndexKey(index.Name, oldMetaRepresentation, index.AttributeIds);
var newKey = IndexTool.BuildIndexKey(index.Name, nnoi, index.AttributeIds);
// Only update index if key has changed!
if (oldKey.CompareTo(newKey) != 0)
{
var btree = index.BTree;
// TODO manage collision!
// Unused old value - result from delete
btree.Delete(oldKey, oid);
// TODO check if old is equal to oldKey
btree.Insert(newKey, oid);
// Check consistency : index should have size equal to the class
// info element number
if (index.BTree.GetSize() != nnoi.GetClassInfo().NumberOfObjects)
{
throw new OdbRuntimeException(
NDatabaseError.BtreeSizeDiffersFromClassElementNumber.AddParameter(index.BTree.GetSize())
.AddParameter(nnoi.GetClassInfo().NumberOfObjects));
}
}
}
}
private IOdbComparable BuildOrderByKey(NonNativeObjectInfo nnoi)
{
// TODO cache the attributes ids to compute them only once
var queryManager = DependencyContainer.Resolve <IQueryManager>();
var orderByAttributeIds = queryManager.GetOrderByAttributeIds(ClassInfo, Query);
return(IndexTool.BuildIndexKey("OrderBy", nnoi, orderByAttributeIds));
}
/// <summary>
/// Take the fields of the index and take value from the query
/// </summary>
/// <param name="index"> The index </param>
/// <returns> The key of the index </returns>
protected virtual IOdbComparable ComputeIndexKey(ClassInfoIndex index)
{
var attributesNames = ClassInfo.GetAttributeNames(index.AttributeIds);
var constraint = Query.GetCriteria();
var values = ((IInternalConstraint)constraint).GetValues();
return(IndexTool.BuildIndexKey(index.Name, values, attributesNames));
}
// This method os not used in Values Query API
public void ObjectMatch(OID oid, object @object, IOdbComparable orderByKey)
{
var values = (AttributeValuesMap)@object;
var groupByKey = IndexTool.BuildIndexKey("GroupBy", values, _groupByFieldList);
var result = _groupByResult[groupByKey];
if (result == null)
{
result = new ValuesQueryResultAction(_query, null, _instanceBuilder);
result.Start();
_groupByResult.Add(groupByKey, result);
}
result.ObjectMatch(oid, @object, orderByKey);
}
private DownloadTarget[] InternalGetVersionFilesInfo(FullVersionId fullVersionId)
{
_log.Info($"Collecting files info for version {fullVersionId}...");
var result = new List <DownloadTarget>(1024);
var prefix = fullVersionId.Prefix;
var version = fullVersionId.Version;
var basePath = Path.Combine(_versionsPath, prefix, version);
var baseUrl = $"{_storeUrl}/{prefix}/{version}";
_log.Info($"Add {version}.jar to list");
var dataIndex = _json.ReadFile <VersionDataIndex>(Path.Combine(basePath, "data.json"));
var jarPath = Path.Combine(basePath, $"{version}.jar");
var jarUrl = $"{baseUrl}/{version}.jar";
result.Add(new DownloadTarget(jarPath, jarUrl, dataIndex.Main.Size, dataIndex.Main.Hash));
if (dataIndex.Files?.Index != null)
{
_log.Info("Add custom files to list");
foreach (var(relativePath, info) in dataIndex.Files.Index)
{
var path = Path.Combine(basePath, "files", relativePath);
var url = $"{baseUrl}/files/{relativePath}";
result.Add(new DownloadTarget(path, url, info.Size, info.Hash));
}
}
_log.Info("Add libraries to list");
var versionIndex = _json.ReadFile <VersionIndex>(Path.Combine(basePath, $"{version}.json"));
AppendLibsInfo(versionIndex, dataIndex, result);
_log.Info("Add assets to list");
var assetsIndexRelativePath = IndexTool.GetAssetIndexPath(versionIndex);
var assetsIndexPath = Path.Combine(_assetsPath, "indexes", assetsIndexRelativePath);
var assetsIndex = _json.ReadFile <AssetsIndex>(assetsIndexPath);
AppendAssets(assetsIndex.Objects, result);
_log.Info($"Complete! Total files: {result.Count}");
return(result.ToArray());
}
private async Task InternalFetchVersionIndexes(FullVersionId fullVersionId)
{
var basePath = Path.Combine(_versionsPath, fullVersionId.Prefix, fullVersionId.Version);
var baseUrl = $"{_storeUrl}/{fullVersionId.Prefix}/{fullVersionId.Version}";
var versionIndexName = $"{fullVersionId.Version}.json";
foreach (var fileName in new[] { versionIndexName, "data.json" })
{
var url = $"{baseUrl}/{fileName}";
var path = Path.Combine(basePath, fileName);
await DownloadFile(path, url);
}
var versionIndex = _json.ReadFile <VersionIndex>(Path.Combine(basePath, versionIndexName));
var assetsIndexRelativePath = IndexTool.GetAssetIndexPath(versionIndex);
var assetsIndexPath = Path.Combine(_assetsPath, "indexes", assetsIndexRelativePath);
var assetsIndexUrl = $"{_storeUrl}/assets/indexes/{assetsIndexRelativePath}";
await DownloadFile(assetsIndexPath, assetsIndexUrl);
}
private void AppendLibsInfo(VersionIndex vIndex, VersionDataIndex dIndex, List <DownloadTarget> list)
{
foreach (var libraryInfo in vIndex.Libraries)
{
if (!IndexTool.IsLibraryAllowed(libraryInfo))
{
continue;
}
var relativePath = IndexTool.GetLibraryPath(libraryInfo);
if (!dIndex.Libs.ContainsKey(relativePath))
{
_log.Warn($"Data index does not contain library {libraryInfo.Name}");
continue;
}
var path = Path.Combine(_librariesPath, relativePath);
var url = $"{_storeUrl}/libraries/{relativePath}";
var fileInfo = dIndex.Libs[relativePath];
list.Add(new DownloadTarget(path, url, fileInfo.Size, fileInfo.Hash));
}
}
public void AddIndexOn(string className, string indexName, string[] indexFields,
bool acceptMultipleValuesForSameKey)
{
var classInfo = GetMetaModel().GetClassInfo(className, true);
if (classInfo.HasIndex(indexName))
{
throw new OdbRuntimeException(
NDatabaseError.IndexAlreadyExist.AddParameter(indexName).AddParameter(className));
}
var classInfoIndex = classInfo.AddIndexOn(indexName, indexFields, acceptMultipleValuesForSameKey);
IBTree btree;
var lazyOdbBtreePersister = new LazyOdbBtreePersister(this);
if (acceptMultipleValuesForSameKey)
{
btree = new OdbBtreeMultiple(OdbConfiguration.GetIndexBTreeDegree(), lazyOdbBtreePersister);
}
else
{
btree = new OdbBtreeSingle(OdbConfiguration.GetIndexBTreeDegree(), lazyOdbBtreePersister);
}
classInfoIndex.BTree = btree;
Store(classInfoIndex);
// Now The index must be updated with all existing objects.
if (classInfo.NumberOfObjects == 0)
{
// There are no objects. Nothing to do
return;
}
var numberOfObjectsAsString = classInfo.NumberOfObjects.ToString();
Log4NetHelper.Instance.LogInfoMessage(
string.Format(
"StorageEngine: Creating index {0} on class {1} - Class has already {2} Objects. Updating index",
indexName, className, numberOfObjectsAsString));
Log4NetHelper.Instance.LogInfoMessage(string.Format("StorageEngine: {0} : loading {1} objects from database", indexName,
numberOfObjectsAsString));
// We must load all objects and insert them in the index!
var criteriaQuery = new SodaQuery(classInfo.UnderlyingType);
var objects = GetObjectInfos(criteriaQuery);
numberOfObjectsAsString = classInfo.NumberOfObjects.ToString();
Log4NetHelper.Instance.LogInfoMessage(string.Format("StorageEngine: {0} : {1} objects loaded", indexName, numberOfObjectsAsString));
while (objects.HasNext())
{
var nnoi = (NonNativeObjectInfo)objects.Next();
var odbComparable = IndexTool.BuildIndexKey(classInfoIndex.Name, nnoi, classInfoIndex.AttributeIds);
btree.Insert(odbComparable, nnoi.GetOid());
}
Log4NetHelper.Instance.LogInfoMessage(string.Format("StorageEngine: {0} created!", indexName));
}
private IOdbComparable BuildOrderByKey(AttributeValuesMap values)
{
return(IndexTool.BuildIndexKey("OrderBy", values, Query.GetOrderByFieldNames()));
}
private bool IsCentre(int index) => IndexTool.ToIndex(Centre.Position, Params.Size) == index;
