public IEnumerable <FunctionDefinition> SearchForFunctionDefinitions(string funcName)
{
if (_db == null)
{
yield break;
}
using (var cmd = _db.CreateCommand(@"
select file_.file_name, func.*, alt_file.file_name as alt_file_name from func
inner join file_ on file_.rowid = func.file_id
left outer join alt_file on alt_file.rowid = func.alt_file_id
where func.app_id = @app_id
and func.name = @func_name
" ))
{
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@func_name", funcName);
using (var rdr = cmd.ExecuteReader())
{
var ordFileName = rdr.GetOrdinal("file_name");
while (rdr.Read())
{
yield return(FFFunction.CreateFunctionDefinitionFromSqlReader(rdr, rdr.GetString(ordFileName)));
}
}
}
}
public void InsertOrUpdate(FFDatabase db, CodeModel.FileStore store, CodeModel.CodeModel model)
{
if (_id != 0)
{
using (var cmd = db.CreateCommand("update file_ set modified = @modified, visible = @visible where rowid = @id"))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.Parameters.AddWithValue("@modified", _modified);
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
cmd.ExecuteNonQuery();
}
}
else
{
using (var cmd = db.CreateCommand(
"insert into file_ (app_id, file_name, modified, visible) values (@app_id, @file_name, @modified, @visible);"
+ " select last_insert_rowid();"))
{
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_name", _fileName);
cmd.Parameters.AddWithValue("@modified", _modified);
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
_id = Convert.ToInt64(cmd.ExecuteScalar());
}
}
UpdateIncludeDependencies(db, store, model);
}
private void UpdatePermExList(FFDatabase db, IEnumerable <CodeModel.Tokens.Statements.ExtractStatement> exList)
{
var keptPermExs = new List <FFPermEx>();
foreach (var extract in exList)
{
FFPermEx permEx = _permExs.FirstOrDefault(p => p.Name == extract.Name);
if (permEx != null)
{
permEx.UpdateFromToken(extract);
}
else
{
var token = extract.FindFirstChild <ExtractTableToken>();
if (token == null)
{
continue;
}
var def = token.SourceDefinition as ExtractTableDefinition;
if (def == null)
{
continue;
}
permEx = new FFPermEx(this, extract, def);
_permExs.Add(permEx);
}
permEx.SyncToDatabase(db);
keptPermExs.Add(permEx);
}
// Remove deleted extracts
var exsToDelete = _permExs.Where(p => !keptPermExs.Any(k => k.Name == p.Name)).ToArray();
if (exsToDelete.Length > 0)
{
using (var cmd = db.CreateCommand("delete from permex_col where permex_id = @permex_id"))
{
foreach (var permex in exsToDelete)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@permex_id", permex.Id);
cmd.ExecuteNonQuery();
}
}
using (var cmd = db.CreateCommand("delete from permex where rowid = @id"))
{
foreach (var permex in exsToDelete)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@id", permex.Id);
cmd.ExecuteNonQuery();
}
}
}
}
public void Remove(FFDatabase db)
{
if (_id != 0)
{
using (var cmd = db.CreateCommand("delete from file_ where rowid = @id"))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from func where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.ExecuteNonQuery();
}
}
}
public long GetOrCreateAltFileId(FFDatabase db, string fileName)
{
using (var cmd = db.CreateCommand("select rowid from alt_file where file_name = @file_name limit 1"))
{
cmd.Parameters.AddWithValue("@file_name", fileName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (rdr.Read())
{
return(rdr.GetInt64(0));
}
}
}
using (var cmd = db.CreateCommand("insert into alt_file (file_name) values (@file_name); select last_insert_rowid();"))
{
cmd.Parameters.AddWithValue("@file_name", fileName);
return(Convert.ToInt64(cmd.ExecuteScalar()));
}
}
public void Load(FFDatabase db)
{
_fields.Clear();
using (var cmd = db.CreateCommand(@"
select name, pos, data_type, alt_file.file_name as alt_file_name from permex_col
left outer join alt_file on alt_file.rowid = permex_col.alt_file_id
where permex_id = @id
" ))
{
cmd.Parameters.AddWithValue("@id", _id);
using (var rdr = cmd.ExecuteReader())
{
var ordName = rdr.GetOrdinal("name");
var ordAltFileName = rdr.GetOrdinal("alt_file_name");
var ordPos = rdr.GetOrdinal("pos");
var ordDataType = rdr.GetOrdinal("data_type");
while (rdr.Read())
{
var name = rdr.GetString(ordName);
var fileName = rdr.GetStringOrNull(ordAltFileName);
if (string.IsNullOrEmpty(fileName))
{
fileName = _file.FileName;
}
var pos = rdr.GetInt32(ordPos);
var filePos = new FilePosition(fileName, pos);
var fieldDef = new ExtractFieldDefinition(name, filePos, _def);
_fields.Add(fieldDef);
_def.AddField(fieldDef);
var dataTypeString = rdr.GetString(ordDataType);
if (!string.IsNullOrEmpty(dataTypeString))
{
var dataType = DataType.TryParse(new DataType.ParseArgs {
Code = new CodeParser(dataTypeString)
});
if (dataType == null)
{
Log.Debug("Failed to parse permanent extract data type from database: {0}", dataTypeString);
dataType = new CodeModel.DataType(ValType.Unknown, null,
new Classifier.ProbeClassifiedString(Classifier.ProbeClassifierType.DataType, dataTypeString));
}
fieldDef.SetDataType(dataType);
}
}
}
}
}
public void Load(FFDatabase db)
{
using (var cmd = db.CreateCommand(
"select func.rowid, func.*, alt_file.file_name as alt_file_name from func" +
" left outer join alt_file on alt_file.rowid = func.alt_file_id" +
" where file_id = @file_id"))
{
cmd.Parameters.AddWithValue("@file_id", _id);
using (var funcRdr = cmd.ExecuteReader())
{
while (funcRdr.Read())
{
_functions.Add(new FFFunction(_app, this, _class, funcRdr));
}
}
}
using (var cmd = db.CreateCommand(
"select permex.rowid, permex.*, alt_file.file_name as alt_file_name from permex" +
" left outer join alt_file on alt_file.rowid = permex.alt_file_id" +
" where permex.file_id = @file_id"))
{
cmd.Parameters.AddWithValue("@file_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
_permExs.Add(new FFPermEx(this, rdr));
}
}
}
foreach (var permex in _permExs)
{
permex.Load(db);
}
}
private void PurgeNonexistentApps(FFDatabase db)
{
var appsToRemove = new Dictionary <long, string>();
var appNames = _appSettings.AllAppNames.ToArray();
using (var cmd = db.CreateCommand("select rowid, name from app"))
{
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
var name = rdr.GetString(1);
if (!appNames.Any(a => string.Equals(a, name, StringComparison.OrdinalIgnoreCase)))
{
appsToRemove[rdr.GetInt64(0)] = name;
}
}
}
}
foreach (var appId in appsToRemove.Keys)
{
Log.Write(LogLevel.Info, "Removing app {0} from database because it no longer exists in the DK environment.", appsToRemove[appId]);
using (var cmd = db.CreateCommand("delete from func where app_id = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", appId);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from include_depends where app_id = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", appId);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from ref where app_id = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", appId);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from file_ where app_id = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", appId);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from app where rowid = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", appId);
cmd.ExecuteNonQuery();
}
}
}
public long GetAltFileId(FFDatabase db, string fileName)
{
using (var cmd = db.CreateCommand("select rowid from alt_file where file_name = @file_name limit 1"))
{
cmd.Parameters.AddWithValue("@file_name", fileName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (rdr.Read())
{
return(rdr.GetInt64(0));
}
}
}
return(0L);
}
public FFFile GetFileForScan(FFDatabase db, string fileName)
{
FFFile file;
var fileNameLower = fileName.ToLower();
lock (_files)
{
if (_files.TryGetValue(fileNameLower, out file))
{
return(file);
}
}
// Check if this is in the list of invisible files.
if (_invisibleFiles.ContainsKey(fileNameLower))
{
using (var cmd = db.CreateCommand("select rowid, * from file_ where app_id = @app_id and file_name = @file_name"))
{
cmd.Parameters.AddWithValue("@app_id", _id);
cmd.Parameters.AddWithValue("@file_name", fileName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (rdr.Read())
{
file = new FFFile(this, db, rdr);
}
}
}
}
if (file != null)
{
// Was loaded as invisible file
file.Load(db);
return(file);
}
// New file
file = new FFFile(this, fileName);
return(file);
}
public void PurgeData(FFDatabase db)
{
// Remove files in memory that don't exist on disk.
{
var removeFiles = new List <FFFile>();
foreach (var file in _files.Values)
{
if (!File.Exists(file.FileName))
{
removeFiles.Add(file);
}
}
foreach (var removeFile in removeFiles)
{
_files.Remove(removeFile.FileName.ToLower());
removeFile.Remove(db);
}
}
// Remove files in the database that aren't in memory.
{
var removeFiles = new List <long>();
using (var cmd = db.CreateCommand("select rowid, file_name from file_ where app_id = @app_id"))
{
cmd.Parameters.AddWithValue("@app_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
var id = rdr.GetInt64(0);
var fileNameLower = rdr.GetString(1).ToLower();
if (!_files.ContainsKey(fileNameLower) &&
!_invisibleFiles.ContainsKey(fileNameLower))
{
removeFiles.Add(id);
}
}
}
}
foreach (var id in removeFiles)
{
using (var cmd = db.CreateCommand("delete from file_ where rowid = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from func where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from ref where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from include_depends where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from permex_col where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
using (var cmd = db.CreateCommand("delete from permex where file_id = @id"))
{
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
}
}
// Purge alt_file records that are no longer used
List <long> altFilesToRemove = null;
using (var cmd = db.CreateCommand("select rowid from alt_file" +
" where not exists (select * from func where alt_file_id = alt_file.rowid)" +
" and not exists (select * from ref where alt_file_id = alt_file.rowid)" +
" and not exists (select * from permex where alt_file_id = alt_file.rowid)" +
" and not exists (select * from permex_col where alt_file_id = alt_file.rowid)"))
{
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
if (altFilesToRemove == null)
{
altFilesToRemove = new List <long>();
}
altFilesToRemove.Add(rdr.GetInt64(0));
}
}
}
if (altFilesToRemove != null)
{
using (var cmd = db.CreateCommand("delete from alt_file where rowid = @id"))
{
foreach (var id in altFilesToRemove)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
}
}
PurgeNonexistentApps(db);
}
public FFApp(FFScanner scanner, FFDatabase db, ProbeAppSettings appSettings)
{
_scanner = scanner ?? throw new ArgumentNullException(nameof(scanner));
_appSettings = appSettings ?? throw new ArgumentNullException(nameof(appSettings));
if (!_appSettings.Initialized)
{
return;
}
var conn = db.Connection;
if (conn == null)
{
return;
}
// Load app info
using (var cmd = db.CreateCommand("select rowid from app where name = @name"))
{
cmd.Parameters.AddWithValue("@name", _appSettings.AppName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (rdr.Read())
{
_id = rdr.GetInt64(0);
}
}
}
if (_id != 0)
{
// Load files
var loadedFiles = new List <FFFile>();
using (var cmd = db.CreateCommand("select rowid, * from file_ where app_id = @app_id and visible != 0"))
{
cmd.Parameters.AddWithValue("@app_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
loadedFiles.Add(new FFFile(this, db, rdr));
}
}
}
foreach (var file in loadedFiles)
{
file.Load(db);
_files[file.FileName.ToLower()] = file;
}
using (var cmd = db.CreateCommand("select file_name, modified from file_ where app_id = @app_id and visible = 0"))
{
cmd.Parameters.AddWithValue("@app_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
var fileName = rdr.GetString(0);
var modified = rdr.GetDateTime(1);
_invisibleFiles[fileName.ToLower()] = modified;
}
}
}
}
else // _id == 0
{
using (var cmd = db.CreateCommand("insert into app (name) values (@name); select last_insert_rowid();"))
{
cmd.Parameters.AddWithValue("@name", _appSettings.AppName);
_id = Convert.ToInt64(cmd.ExecuteScalar());
}
var options = ProbeToolsPackage.Instance.EditorOptions;
if (!options.DisableBackgroundScan)
{
Shell.ShowNotificationAsync(Res.FFDatabaseCreationNotification, Res.FFDatabaseCreationCaption);
}
}
}
private void UpdateRefList(FFDatabase db, List <Reference> refList)
{
// Initialize the flags on each ref
var memRefs = new List <Reference>();
memRefs.AddRange(refList);
foreach (var r in memRefs)
{
r.Exists = false;
}
List <long> dbRefsToRemove = null;
// Scan the refs in the database to find which ones should be updated or removed
using (var cmd = db.CreateCommand("select ref.rowid, ref.*, alt_file.file_name as true_file_name from ref "
+ "left outer join alt_file on alt_file.rowid = ref.alt_file_id "
+ "where file_id = @file_id"))
{
cmd.Parameters.AddWithValue("@file_id", _id);
using (var rdr = cmd.ExecuteReader())
{
var ordId = rdr.GetOrdinal("rowid");
var ordExtRefId = rdr.GetOrdinal("ext_ref_id");
var ordTrueFileName = rdr.GetOrdinal("true_file_name");
var ordPos = rdr.GetOrdinal("pos");
while (rdr.Read())
{
var id = rdr.GetInt64(ordId);
var extRefId = rdr.GetString(ordExtRefId);
var trueFileName = rdr.GetStringOrNull(ordTrueFileName);
var pos = rdr.GetInt32(ordPos);
var memRef = memRefs.FirstOrDefault(r => r.ExternalRefId == extRefId &&
(r.TrueFileName == null) == (trueFileName == null) &&
(r.TrueFileName == null || string.Equals(r.TrueFileName, trueFileName, StringComparison.OrdinalIgnoreCase)) &&
r.Position == pos);
if (memRef != null)
{
memRef.Exists = true;
}
else
{
if (dbRefsToRemove == null)
{
dbRefsToRemove = new List <long>();
}
dbRefsToRemove.Add(id);
}
}
}
}
// Remove refs no longer used
if (dbRefsToRemove != null)
{
using (var cmd = db.CreateCommand("delete from ref where rowid = @id"))
{
foreach (var id in dbRefsToRemove)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@id", id);
cmd.ExecuteNonQuery();
}
}
}
// Insert new refs
if (memRefs.Any(r => !r.Exists))
{
// Get the list of alt file names used.
var altFileNames = new Dictionary <string, long>();
foreach (var altFileName in (from r in memRefs where !r.Exists && !string.IsNullOrEmpty(r.TrueFileName) select r.TrueFileName))
{
if (!altFileNames.Keys.Any(x => string.Equals(x, altFileName)))
{
altFileNames[altFileName] = 0;
}
}
if (altFileNames.Any())
{
// Look up the IDs of any alt file names used.
using (var cmd = db.CreateCommand("select rowid from alt_file where file_name = @file_name limit 1"))
{
foreach (var altFileName in altFileNames.Keys.ToArray()) // Put into array early to avoid collection modified error
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@file_name", altFileName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (rdr.Read())
{
altFileNames[altFileName] = rdr.GetInt64(0);
}
}
}
}
// Insert new alt file names.
if (altFileNames.Any(x => x.Value == 0))
{
using (var cmd = db.CreateCommand("insert into alt_file (file_name) values (@file_name); select last_insert_rowid();"))
{
foreach (var altFileName in (from a in altFileNames where a.Value == 0 select a.Key).ToArray()) // Put into array early to avoid collection modified error
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@file_name", altFileName);
altFileNames[altFileName] = Convert.ToInt64(cmd.ExecuteScalar());
}
}
}
}
// Inserts the ref records
using (var cmd = db.CreateCommand("insert into ref (app_id, file_id, ext_ref_id, alt_file_id, pos)" +
" values (@app_id, @file_id, @ext_ref_id, @alt_file_id, @pos)"))
{
foreach (var newRef in memRefs.Where(r => !r.Exists))
{
var trueFileId = 0L;
if (!string.IsNullOrEmpty(newRef.TrueFileName))
{
var altFileName = (from a in altFileNames where string.Equals(a.Key, newRef.TrueFileName, StringComparison.OrdinalIgnoreCase) select a.Key).FirstOrDefault();
if (altFileName != null)
{
trueFileId = altFileNames[altFileName];
}
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_id", _id);
cmd.Parameters.AddWithValue("@ext_ref_id", newRef.ExternalRefId);
cmd.Parameters.AddWithValue("@alt_file_id", trueFileId);
cmd.Parameters.AddWithValue("@pos", newRef.Position);
cmd.ExecuteNonQuery();
}
}
}
}
private void UpdateIncludeDependencies(FFDatabase db, CodeModel.FileStore store, CodeModel.CodeModel model)
{
var modelIncludeList = model.PreprocessorModel.IncludeDependencies.ToArray();
var dbIncludes = new List <DbInclude>();
using (var cmd = db.CreateCommand("select rowid, include_file_name, include, localized_file from include_depends where file_id = @file_id"))
{
cmd.Parameters.AddWithValue("@file_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
dbIncludes.Add(new DbInclude
{
id = rdr.GetInt64(0),
fileName = rdr.GetString(1),
include = rdr.GetTinyIntBoolean(2),
localizedFile = rdr.GetTinyIntBoolean(3)
});
}
}
}
// Remove dependencies that are no longer there
var recordsToRemove = (from d in dbIncludes
where !modelIncludeList.Any(m => m.FileName.Equals(d.fileName, StringComparison.OrdinalIgnoreCase) &&
m.Include == d.include &&
m.LocalizedFile == d.localizedFile)
select d).ToArray();
if (recordsToRemove.Length > 0)
{
using (var cmd = db.CreateCommand("delete from include_depends where rowid = @rowid"))
{
foreach (var id in recordsToRemove)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@rowid", id);
cmd.ExecuteNonQuery();
}
}
}
// Add new dependencies
var recordsToAdd = (from m in modelIncludeList
where !dbIncludes.Any(d => d.fileName.Equals(m.FileName, StringComparison.OrdinalIgnoreCase) &&
d.include == m.Include &&
d.localizedFile == m.LocalizedFile)
select m).ToArray();
if (recordsToAdd.Length > 0)
{
using (var cmd = db.CreateCommand(@"
insert into include_depends (app_id, file_id, include_file_name, include, localized_file)
values (@app_id, @file_id, @include_file_name, @include, @localized_file)
" ))
{
foreach (var incl in recordsToAdd)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_id", _id);
cmd.Parameters.AddWithValue("@include_file_name", incl.FileName);
cmd.Parameters.AddWithValue("@include", incl.Include ? 1 : 0);
cmd.Parameters.AddWithValue("@localized_file", incl.LocalizedFile ? 1 : 0);
cmd.ExecuteNonQuery();
}
}
}
}
public void SyncToDatabase(FFDatabase db)
{
long trueFileId = string.Equals(_filePos.FileName, _file.FileName, StringComparison.OrdinalIgnoreCase) ? 0L :
_file.App.GetOrCreateAltFileId(db, _filePos.FileName);
if (_id == 0)
{
// Insert the master record
using (var cmd = db.CreateCommand(@"
insert into permex (app_id, file_id, name, alt_file_id, pos)
values (@app_id, @file_id, @name, @alt_file_id, @pos);
select last_insert_rowid()
" ))
{
cmd.Parameters.AddWithValue("@app_id", _file.App.Id);
cmd.Parameters.AddWithValue("@file_id", _file.Id);
cmd.Parameters.AddWithValue("@name", _name);
cmd.Parameters.AddWithValue("@alt_file_id", trueFileId);
cmd.Parameters.AddWithValue("@pos", _filePos.Position);
_id = Convert.ToInt64(cmd.ExecuteScalar());
}
// Insert all the fields
foreach (var field in _fields)
{
var fieldFilePos = field.FilePosition;
var fieldTrueFileId = string.Equals(fieldFilePos.FileName, _file.FileName, StringComparison.OrdinalIgnoreCase) ? 0 :
_file.App.GetOrCreateAltFileId(db, fieldFilePos.FileName);
var fieldDataType = field.DataType != null?field.DataType.ToCodeString() : string.Empty;
using (var cmd = db.CreateCommand(@"
insert into permex_col (permex_id, file_id, name, data_type, alt_file_id, pos)
values (@permex_id, @file_id, @name, @data_type, @alt_file_id, @pos)
" ))
{
cmd.Parameters.AddWithValue("@permex_id", _id);
cmd.Parameters.AddWithValue("@file_id", _file.Id);
cmd.Parameters.AddWithValue("@name", field.Name);
cmd.Parameters.AddWithValue("@data_type", fieldDataType);
cmd.Parameters.AddWithValue("@alt_file_id", fieldTrueFileId);
cmd.Parameters.AddWithValue("@pos", fieldFilePos.Position);
cmd.ExecuteNonQuery();
}
}
}
else
{
// Update the master record
using (var cmd = db.CreateCommand("update permex set alt_file_id = @alt_file_id, pos = @pos where rowid = @id"))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.Parameters.AddWithValue("@alt_file_id", trueFileId);
cmd.Parameters.AddWithValue("@pos", _filePos.Position);
}
// Get a list of fields under this extract
var dbNames = new Dictionary <string, long>();
using (var cmd = db.CreateCommand("select rowid, name from permex_col where permex_id = @permex_id"))
{
cmd.Parameters.AddWithValue("@permex_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
var id = rdr.GetInt64(0);
var name = rdr.GetString(1);
dbNames[name] = id;
}
}
}
// Sync the fields under this record
foreach (var field in _fields)
{
var fieldFilePos = field.FilePosition;
var fieldTrueFileId = string.Equals(fieldFilePos.FileName, _file.FileName, StringComparison.OrdinalIgnoreCase) ? 0 :
_file.App.GetOrCreateAltFileId(db, fieldFilePos.FileName);
var fieldDataType = field.DataType != null?field.DataType.ToCodeString() : string.Empty;
if (dbNames.ContainsKey(field.Name))
{
// Field already exists in the database, so update it
using (var cmd = db.CreateCommand(@"
update permex_col set
data_type = @data_type,
alt_file_id = @alt_file_id,
pos = @pos
where rowid = @id
" ))
{
cmd.Parameters.AddWithValue("@id", dbNames[field.Name]);
cmd.Parameters.AddWithValue("@data_type", fieldDataType);
cmd.Parameters.AddWithValue("@alt_file_id", fieldTrueFileId);
cmd.Parameters.AddWithValue("@pos", fieldFilePos.Position);
cmd.ExecuteNonQuery();
}
}
else
{
// Field does not yet exist in the database, so insert a new one
using (var cmd = db.CreateCommand(@"
insert into permex_col (permex_id, file_id, name, data_type, alt_file_id, pos)
values (@permex_id, @file_id, @name, @data_type, @alt_file_id, @pos)
" ))
{
cmd.Parameters.AddWithValue("@permex_id", _id);
cmd.Parameters.AddWithValue("@file_id", _file.Id);
cmd.Parameters.AddWithValue("@name", field.Name);
cmd.Parameters.AddWithValue("@data_type", fieldDataType);
cmd.Parameters.AddWithValue("@alt_file_id", fieldTrueFileId);
cmd.Parameters.AddWithValue("@pos", fieldFilePos.Position);
cmd.ExecuteNonQuery();
}
}
}
// Check for fields that no longer exist and need to be deleted from the database
var fieldIdsToDelete = (from d in dbNames where !_fields.Any(f => d.Key == f.Name) select d.Value).ToArray();
if (fieldIdsToDelete.Length > 0)
{
using (var cmd = db.CreateCommand("delete from permex_col where rowid = @id"))
{
foreach (var fieldId in fieldIdsToDelete)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@id", fieldId);
cmd.ExecuteNonQuery();
}
}
}
}
}
private void EnqueueFilesDependentOnInclude(string includeFileName)
{
if (_currentApp == null)
{
return;
}
var options = ProbeToolsPackage.Instance.EditorOptions;
if (options.DisableBackgroundScan)
{
return;
}
using (var db = new FFDatabase())
{
var fileIds = new Dictionary <long, string>();
using (var cmd = db.CreateCommand(@"
select file_id, file_name from include_depends
inner join file_ on file_.rowid = include_depends.file_id
where include_depends.app_id = @app_id
and include_depends.include_file_name = @include_file_name
" ))
{
cmd.Parameters.AddWithValue("@app_id", _currentApp.Id);
cmd.Parameters.AddWithValue("@include_file_name", includeFileName);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
var fileName = rdr.GetString(1);
var context = FileContextUtil.GetFileContextFromFileName(fileName);
if (context != FileContext.Include && context != FileContext.Dictionary)
{
fileIds[rdr.GetInt64(0)] = fileName;
}
}
}
}
if (fileIds.Any())
{
Log.Debug("Resetting modified date on {0} file(s).", fileIds.Count);
using (var txn = db.BeginTransaction())
{
using (var cmd = db.CreateCommand("update file_ set modified = '1900-01-01' where rowid = @id"))
{
foreach (var item in fileIds)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@id", item.Key);
cmd.ExecuteNonQuery();
_currentApp.TrySetFileDate(item.Value, DateTime.MinValue);
}
}
txn.Commit();
}
}
}
RestartScanning("Include file changed; scanning dependent files.");
}
public void InsertOrUpdate(FFDatabase db)
{
var sb = new StringBuilder();
var first = true;
foreach (var arg in _def.Arguments)
{
if (first)
{
first = false;
}
else
{
sb.Append('|');
}
sb.Append(arg.ToDbString());
}
var argsString = sb.ToString();
var altFileId = 0L;
var filePos = _def.FilePosition;
if (!string.Equals(filePos.FileName, _file.FileName, StringComparison.OrdinalIgnoreCase))
{
altFileId = _app.GetAltFileId(db, filePos.FileName);
}
if (_id != 0)
{
// TODO: next database version, remove description field
using (var cmd = db.CreateCommand(@"
update func set file_id = @file_id, name = @name, sig = @sig, alt_file_id = @alt_file_id, pos = @pos,
description = null, visible = @visible where rowid = @id
" ))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.Parameters.AddWithValue("@file_id", _file.Id);
cmd.Parameters.AddWithValue("@name", _name);
cmd.Parameters.AddWithValue("@sig", _sig.ToDbString());
cmd.Parameters.AddWithValue("@alt_file_id", altFileId);
cmd.Parameters.AddWithValue("@pos", filePos.Position);
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
cmd.ExecuteNonQuery();
}
}
else
{
using (var cmd = db.CreateCommand(@"
insert into func (name, app_id, file_id, alt_file_id, pos, sig, visible)
values (@name, @app_id, @file_id, @alt_file_id, @pos, @sig, @visible);
select last_insert_rowid();
" ))
{
cmd.Parameters.AddWithValue("@name", _name);
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_id", _file.Id);
cmd.Parameters.AddWithValue("@alt_file_id", altFileId);
cmd.Parameters.AddWithValue("@pos", filePos.Position);
cmd.Parameters.AddWithValue("@sig", _sig.ToDbString());
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
_id = Convert.ToInt64(cmd.ExecuteScalar());
}
}
}
