private static async Task <CompileInfo> CompileAsync(IDatabase database, string tableName, IRedis redis, Query query)
{
var method = query.Method;
if (method == "update")
{
query.Method = "select";
}
string sql;
Dictionary <string, object> namedBindings;
var compiler = DbUtils.GetCompiler(database.DatabaseType, database.ConnectionString);
var compiled = compiler.Compile(query);
if (method == "update")
{
var bindings = new List <object>();
var setList = new List <string>();
var components = query.GetComponents("update");
components.Add(new BasicCondition
{
Column = nameof(Entity.LastModifiedDate),
Value = DateTime.Now
});
foreach (var clause in components)
{
if (clause is RawCondition raw)
{
var set = compiler.WrapIdentifiers(raw.Expression);
if (setList.Contains(set, StringComparer.OrdinalIgnoreCase))
{
continue;
}
setList.Add(set);
if (raw.Bindings != null)
{
bindings.AddRange(raw.Bindings);
}
}
else if (clause is BasicCondition basic)
{
var set = compiler.Wrap(basic.Column) + " = ?";
if (setList.Contains(set, StringComparer.OrdinalIgnoreCase))
{
continue;
}
setList.Add(set);
bindings.Add(basic.Value);
}
}
bindings.AddRange(compiled.Bindings);
var result = new SqlResult
{
Query = query
};
var where = compiler.CompileWheres(result);
sql = $"UPDATE {tableName} SET { string.Join(", ", setList)} {where}";
//sql = Helper.ExpandParameters(sql, "?", bindings.ToArray());
sql = Helper.ReplaceAll(sql, "?", i => "@p" + i);
namedBindings = Helper.Flatten(bindings).Select((v, i) => new { i, v })
.ToDictionary(x => "@p" + x.i, x => x.v);
}
else
{
sql = compiled.Sql;
namedBindings = compiled.NamedBindings;
}
var compileInfo = new CompileInfo
{
Sql = sql,
NamedBindings = namedBindings
};
var cacheList = query.GetComponents <CachingCondition>("cache");
if (cacheList != null && cacheList.Count > 0)
{
var cacheManager = await CachingUtils.GetCacheManagerAsync(redis);
foreach (var caching in cacheList)
{
if (caching.Action == CachingAction.Remove && caching.CacheKeysToRemove != null)
{
foreach (var cacheKey in caching.CacheKeysToRemove)
{
cacheManager.Remove(cacheKey);
}
}
else if (caching.Action == CachingAction.Get)
{
compileInfo.Caching = caching;
}
}
}
return(compileInfo);
}
/// <summary>
/// Set no lock.
/// </summary>
public void Set()
{
_lockTTL = _ttl.Ticks;
_lastTimeStamp = CachingUtils.DiffTicks(DateTime.Now);
}
/// <summary>
/// Verifica se já expirou.
/// </summary>
/// <returns></returns>
public bool HasExpired()
{
return(SortKey.CompareTo(CachingUtils.DiffTicks(DateTime.Now)) < 0);
}
private IEnumerator DoLoadBundles(string databaseId)
{
Console_WriteLine("Loading database " + databaseId + "...");
if (LoadingStart != null)
{
LoadingStart();
}
var database = LoadAssetBundlesDatabaseFromId(databaseId);
if (LoadStart != null)
{
LoadStart(database);
}
//Console.WriteLine("==== Current language: " + LanguageTextManager.CurSystemLang);
float lastYieldTime = Time.realtimeSinceStartup;
const float maximumYieldTime = 1.0f / 5.0f;
int i = 0;
foreach (var bundleData in database.Bundles)
{
BundleInfo bundleInfo = new BundleInfo(bundleData);
Console_WriteLine("Loading bundle " + bundleData.Name + "...");
string url = UpdateUrl + "/" + databaseId + "/";
int version = CachingUtils.GetVersionFromHash(bundleData.Hash);
if (!Caching.IsVersionCached(bundleData.Filename, version) &&
IsBundleInShippedDatabase(bundleData.Name, version))
{
if (_buildInfo.BundlesCacheIncluded)
{
// Uncompressed cache copy (faster)
Console_WriteLine("Caching " + bundleData.Name);
CopyToCache(_shippedDatabase[bundleData.Name].CacheName);
}
else
{
Console_WriteLine("Caching decompressing " + bundleData.Name);
url = StreamingAssetsUrl + "/Bundles/";
}
}
if (LoadProgress != null)
{
LoadProgress(database.Bundles.IndexOf(bundleData));
}
using (var www = WWW.LoadFromCacheOrDownload(url + bundleData.Filename,
version))
{
yield return(www);
lastYieldTime = Time.realtimeSinceStartup;
bundleInfo.Bundle = www.assetBundle;
}
yield return(null);
foreach (var sceneName in bundleData.SceneNames)
{
_scenesMap.Add(sceneName, bundleInfo);
}
foreach (var assetId in bundleData.AssetsIds)
{
_assetIdMap[assetId] = bundleInfo;
}
_bundlesMap.Add(bundleData.Name, bundleInfo);
// Allow some processing if hanging for too much long
if (Time.realtimeSinceStartup - lastYieldTime > maximumYieldTime)
{
yield return(null);
lastYieldTime = Time.realtimeSinceStartup;
}
i++;
if (i % 30 == 0)
{
yield return(new WaitForSeconds(0.5f));
}
}
Console_WriteLine("Database loaded");
if (LoadingFinish != null)
{
LoadingFinish();
}
}
private IEnumerator DoDownloadBundles(string databaseId)
{
ResetUpdateError();
Console_WriteLine("Downloading database " + databaseId + "...");
if (DownloadingStart != null)
{
DownloadingStart();
}
if (DownloadingBundleStart != null)
{
DownloadingBundleStart();
}
if (DownloadingDatabase != null)
{
DownloadingDatabase(databaseId);
}
AssetBundlesDatabase database = _shippedDatabase;
if (databaseId != _shippedDatabase.Id)
{
if (!Caching.IsVersionCached("index", CachingUtils.GetVersionFromId(databaseId)))
{
if (Application.internetReachability == NetworkReachability.NotReachable)
{
ThrowUpdateError(UpdateErrorType.NoInternetAvailable);
yield break;
}
}
// Download requested database
int version = CachingUtils.GetVersionFromId(databaseId);
// This do-while: workaround of unity bug of caching startup delay
do
{
using (WWW www = WWW.LoadFromCacheOrDownload(UpdateUrl + "/" + databaseId + "/index", version))
{
yield return(StartCoroutine(WwwDone(www)));
if (WwwHasBundleError(www))
{
}
else
{
database = www.assetBundle.mainAsset as AssetBundlesDatabase;
www.assetBundle.Unload(false);
}
}
} while (!Caching.IsVersionCached("index", version));
}
else
{
database = _shippedDatabase;
}
int totalDownloadSize = 0;
var bundlesToDownload = new List <AssetBundlesDatabase.BundleData>();
// Check which bundles must be downloaded/cached
foreach (var bundleData in EnumerateUncachedBundles(database))
{
totalDownloadSize += bundleData.Size;
bundlesToDownload.Add(bundleData);
}
if (bundlesToDownload.Count == 0)
{
yield break;
}
if (DownloadStart != null)
{
DownloadStart(database, bundlesToDownload, totalDownloadSize);
}
int totalDownloadedBytes = 0;
if (bundlesToDownload.Count > 0)
{
Console_WriteLine("Will download " + bundlesToDownload.Count + " bundles, with a total of " + totalDownloadSize + " bytes");
string url = UpdateUrl + "/" + databaseId + "/";
//foreach (var bundleData in bundlesToDownload)
for (int i = 0; i < bundlesToDownload.Count;)
{
var bundleData = bundlesToDownload.ElementAt(i);
Console_WriteLine("Downloading bundle " + bundleData.Name + "...");
using (var www = WWW.LoadFromCacheOrDownload(url + bundleData.Filename,
CachingUtils.GetVersionFromHash(bundleData.Hash)))
{
int previousDownloadedBytes = totalDownloadedBytes;
yield return(StartCoroutine(WwwDone(www, () => {
totalDownloadedBytes = previousDownloadedBytes + (int)(www.progress * (float)bundleData.Size);
if (DownloadProgress != null)
{
DownloadProgress(bundlesToDownload.IndexOf(bundleData), totalDownloadedBytes);
}
})));
if (WwwHasBundleError(www))
{
}
else
{
www.assetBundle.Unload(false);
totalDownloadedBytes = previousDownloadedBytes + bundleData.Size;
}
}
i++;
}
}
Console_WriteLine("Database downloaded");
if (DownloadingBundleEnd != null)
{
DownloadingBundleEnd("success", "url");
}
if (DownloadingFinish != null)
{
DownloadingFinish();
}
}
/// <summary>
/// Reseta a instancia.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
internal override bool Reset(CacheRuntimeContext context)
{
_lastTimeStamp = CachingUtils.DiffSeconds(DateTime.Now);
return(base.Reset(context));
}
