static PlaylistSource()
{
add_track_range_command = new HyenaSqliteCommand(@"
INSERT INTO CorePlaylistEntries
(EntryID, PlaylistID, TrackID, ViewOrder)
SELECT null, ?, ItemID, OrderId + ?
FROM CoreCache WHERE ModelID = ?
LIMIT ?, ?"
);
add_track_command = new HyenaSqliteCommand(@"
INSERT INTO CorePlaylistEntries
(EntryID, PlaylistID, TrackID, ViewOrder)
VALUES (null, ?, ?, ?)"
);
add_track_range_from_joined_model_sql = @"
INSERT INTO CorePlaylistEntries
(EntryID, PlaylistID, TrackID, ViewOrder)
SELECT null, ?, TrackID, OrderId + ?
FROM CoreCache c INNER JOIN {0} e ON c.ItemID = e.{1}
WHERE ModelID = ?
LIMIT ?, ?";
remove_track_range_command = new HyenaSqliteCommand(@"
DELETE FROM CorePlaylistEntries WHERE PlaylistID = ? AND
EntryID IN (SELECT ItemID FROM CoreCache
WHERE ModelID = ? LIMIT ?, ?)"
);
}
public AnalyzeLibraryJob() : base(AddinManager.CurrentLocalizer.GetString("Analyzing Song Similarity"))
{
IconNames = new string [] { "audio-x-generic" };
IsBackground = true;
SetResources(Resource.Cpu, Resource.Disk);
PriorityHints = PriorityHints.LongRunning;
var music_id = ServiceManager.SourceManager.MusicLibrary.DbId;
CountCommand = new HyenaSqliteCommand(String.Format(
@"SELECT COUNT(*)
FROM CoreTracks
WHERE PrimarySourceID IN ({0}) AND TrackID NOT IN
(SELECT TrackID FROM MirageTrackAnalysis)",
music_id
));
SelectCommand = new HyenaSqliteCommand(String.Format(@"
SELECT TrackID
FROM CoreTracks
WHERE PrimarySourceID IN ({0}) AND TrackID NOT IN
(SELECT TrackID FROM MirageTrackAnalysis)
ORDER BY Rating DESC, PlayCount DESC LIMIT 1",
music_id
));
CancelMessage = AddinManager.CurrentLocalizer.GetString(
"Are you sure you want to stop Mirage?\n" +
"Shuffle by Similar will only work for the tracks which are already analyzed. " +
"The operation can be resumed at any time from the <i>Tools</i> menu."
);
CanCancel = true;
Register();
}
private void CreatePlaylist(object o, EventArgs args)
{
if (finished)
{
return;
}
finished = true;
try {
PlaylistSource playlist = new PlaylistSource(name, source);
playlist.Save();
source.AddChildSource(playlist);
HyenaSqliteCommand insert_command = new HyenaSqliteCommand(String.Format(
@"INSERT INTO CorePlaylistEntries (PlaylistID, TrackID) VALUES ({0}, ?)", playlist.DbId));
//ServiceManager.DbConnection.BeginTransaction ();
foreach (string uri in uris)
{
// FIXME: Does the following call work if the source is just a PrimarySource (not LibrarySource)?
int track_id = source.GetTrackIdForUri(uri);
if (track_id > 0)
{
ServiceManager.DbConnection.Execute(insert_command, track_id);
}
}
playlist.Reload();
playlist.NotifyUser();
} catch (Exception e) {
Hyena.Log.Exception(e);
}
}
public LyricsDownloadJob(bool force) : base(AddinManager.CurrentLocalizer.GetString("Downloading Lyrics"))
{
PriorityHints = PriorityHints.LongRunning;
IsBackground = true;
CanCancel = true;
DelayShow = true;
SetResources(Resource.Database);
if (force)
{
/*remove from Lyrics Downloads trakcs without lyrics */
ServiceManager.DbConnection.Execute(new HyenaSqliteCommand(@"
DELETE FROM LyricsDownloads WHERE Downloaded = 0"));
}
SelectCommand = new HyenaSqliteCommand(@"
SELECT CoreTracks.TrackID, CoreArtists.Name, CoreTracks.Title, CoreTracks.Uri
FROM CoreTracks, CoreArtists
WHERE
CoreTracks.PrimarySourceID = ? AND
CoreTracks.ArtistID = CoreArtists.ArtistID AND
CoreTracks.TrackID NOT IN (
SELECT TrackID from LyricsDownloads) LIMIT 1",
ServiceManager.SourceManager.MusicLibrary.DbId);
CountCommand = new HyenaSqliteCommand(@"
SELECT count(CoreTracks.TrackID)
FROM CoreTracks
WHERE
CoreTracks.PrimarySourceID = ? AND
CoreTracks.TrackID NOT IN (
SELECT TrackID from LyricsDownloads)",
ServiceManager.SourceManager.MusicLibrary.DbId);
}
public void Run(object o, EventArgs e)
{
Photo[] photos = App.Instance.Organizer.SelectedPhotos();
if (photos.Length == 0)
{
Log.Debug("no photos selected, returning");
return;
}
DateTime import_time = photos[0].Time;
foreach (Photo p in photos)
{
if (p.Time > import_time)
{
import_time = p.Time;
}
}
RollStore rolls = App.Instance.Database.Rolls;
Roll roll = rolls.Create(import_time);
foreach (Photo p in photos)
{
HyenaSqliteCommand cmd = new HyenaSqliteCommand("UPDATE photos SET roll_id = ? " +
"WHERE id = ? ", roll.Id, p.Id);
App.Instance.Database.Database.Execute(cmd);
p.RollId = roll.Id;
}
Log.Debug("RetroactiveRoll done: " + photos.Length + " photos in roll " + roll.Id);
}
void HowOftenAskFill()
{
using (var connection = new HyenaSqliteConnection(QuestionProvider.dbPath)) {
var provider = new QuestionProvider(connection);
var cmd = new HyenaSqliteCommand("UPDATE ? SET HowOftenAsk = 1 WHERE Id = ?;", provider.TableName, bus.CurrentQuestion.Id);
connection.Execute(cmd);
}
}
public override void UpdateUnfilteredAggregates()
{
HyenaSqliteCommand count_command = new HyenaSqliteCommand(String.Format(
"SELECT COUNT(*) {0} AND PodcastItems.IsRead = 0", UnfilteredQuery
));
UnfilteredCount = Connection.Query <int> (count_command);
}
Photo[] Query(HyenaSqliteCommand query)
{
uint timer = Log.DebugTimerStart();
var new_photos = new List <Photo> ();
var query_result = new List <Photo> ();
using (var reader = Database.Query(query)) {
while (reader.Read())
{
uint id = Convert.ToUInt32(reader["id"]);
var photo = LookupInCache(id);
if (photo == null)
{
photo = new Photo(imageFileFactory, thumbnailService, id, Convert.ToInt64(reader["time"]))
{
Description = reader["description"].ToString(),
RollId = Convert.ToUInt32(reader["roll_id"]),
DefaultVersionId = Convert.ToUInt32(reader["default_version_id"]),
Rating = Convert.ToUInt32(reader["rating"])
};
new_photos.Add(photo);
}
query_result.Add(photo);
}
}
bool need_load = false;
string photo_ids = "(";
foreach (var photo in new_photos)
{
AddToCache(photo);
photo_ids = photo_ids + Convert.ToString(photo.Id) + ",";
need_load |= !photo.AllVersionsLoaded;
}
photo_ids += "-1)";
if (need_load)
{
GetAllTags(photo_ids);
GetAllVersions(photo_ids);
foreach (var photo in new_photos)
{
photo.AllVersionsLoaded = true;
}
}
foreach (var photo in new_photos)
{
photo.Changes = null;
}
Log.DebugTimerPrint(timer, $"Query took {{0}} : {query.Text}");
return(query_result.ToArray());
}
private void RemoveTrack(string track)
{
string uri = new SafeUri(track).AbsoluteUri;
string hash_sql = String.Format(
@"SELECT TrackID, MetadataHash FROM CoreTracks WHERE {0} = ? LIMIT 1",
BansheeQuery.UriField.Column
);
long track_id = 0;
string hash = null;
using (var reader = new HyenaDataReader(ServiceManager.DbConnection.Query(hash_sql, uri))) {
if (reader.Read())
{
track_id = reader.Get <long> (0);
hash = reader.Get <string> (1);
}
}
if (hash != null)
{
lock (queue) {
var item = queue.FirstOrDefault(
i => i.ChangeType == WatcherChangeTypes.Created && GetMetadataHash(i) == hash);
if (item != null)
{
item.ChangeType = WatcherChangeTypes.Renamed;
item.OldFullPath = track;
return;
}
}
}
string delete_sql = @"
INSERT INTO CoreRemovedTracks (DateRemovedStamp, TrackID, Uri)
SELECT ?, TrackID, " + BansheeQuery.UriField.Column + @"
FROM CoreTracks WHERE TrackID IN ({0})
;
DELETE FROM CoreTracks WHERE TrackID IN ({0})";
// If track_id is 0, it's a directory.
HyenaSqliteCommand delete_command;
if (track_id > 0)
{
delete_command = new HyenaSqliteCommand(String.Format(delete_sql,
"?"), DateTime.Now, track_id, track_id);
}
else
{
string pattern = StringUtil.EscapeLike(uri) + "/_%";
string select_sql = String.Format(@"SELECT TrackID FROM CoreTracks WHERE {0} LIKE ? ESCAPE '\'",
BansheeQuery.UriField.Column);
delete_command = new HyenaSqliteCommand(String.Format(delete_sql, select_sql),
DateTime.Now, pattern, pattern);
}
ServiceManager.DbConnection.Execute(delete_command);
}
private static IDataReader FindTrackByMetadataHash(string metadata_hash, long [] primary_sources)
{
var command = new HyenaSqliteCommand(String.Format(
get_track_by_metadata_hash,
provider.Select, provider.From, provider.Where));
return(ServiceManager.DbConnection.Query(command,
primary_sources, metadata_hash));
}
public void Refresh()
{
// Wipe the member list clean and repopulate it
string reload_str = String.Format(
@"DELETE FROM CoreSmartPlaylistEntries WHERE SmartPlaylistID = {0};
INSERT INTO CoreSmartPlaylistEntries
(EntryID, SmartPlaylistID, TrackID)
SELECT NULL, {0} as SmartPlaylistID, TrackId FROM {1}
WHERE {2} AND CoreTracks.PrimarySourceID = {3}
{4} {5} {6}",
DbId, DatabaseTrackInfo.Provider.From, DatabaseTrackInfo.Provider.Where,
PrimarySourceId, PrependCondition("AND"), OrderSql, LimitSql
);
ServiceManager.DbConnection.Execute(reload_str);
// If the smart playlist is limited by file size or media duration, limit it here
if (IsLimited && !Limit.RowBased)
{
// Identify where the cut off mark is
HyenaSqliteCommand limit_command = new HyenaSqliteCommand(String.Format(
@"SELECT EntryID, {0}
FROM CoreTracks, CoreSmartPlaylistEntries
WHERE SmartPlaylistID = {1} AND CoreSmartPlaylistEntries.TrackID = CoreTracks.TrackID
ORDER BY EntryID",
Limit.Column, DbId
));
long limit = LimitValue.IntValue * Limit.Factor;
long sum = 0;
long?cut_off_id = null;
using (IDataReader reader = ServiceManager.DbConnection.Query(limit_command)) {
while (reader.Read())
{
sum += Convert.ToInt64(reader[1]);
if (sum > limit)
{
cut_off_id = Convert.ToInt64(reader[0]);
break;
}
}
}
// Remove the playlist entries after the cut off
if (cut_off_id != null)
{
ServiceManager.DbConnection.Execute(new HyenaSqliteCommand(
"DELETE FROM CoreSmartPlaylistEntries WHERE SmartPlaylistID = ? AND EntryID >= ?",
DbId, cut_off_id
));
}
}
refreshed = true;
}
protected override void IterateCore(HyenaDataReader reader)
{
DatabaseTrackInfo track = DatabaseTrackInfo.Provider.Load(reader.Reader);
var write_delay = track.DateUpdated.AddSeconds(2) - DateTime.Now;
if (write_delay.TotalMilliseconds > 0)
{
System.Threading.Thread.Sleep(write_delay);
return;
}
bool wrote = false;
bool renamed = false;
try {
if (WriteMetadataEnabled || WriteRatingsAndPlayCountsEnabled)
{
Hyena.Log.DebugFormat("Saving metadata for {0}", track);
wrote = StreamTagger.SaveToFile(track, WriteMetadataEnabled, WriteRatingsAndPlayCountsEnabled);
}
// Rename tracks only from the Music Library
if (RenameEnabled &&
track.PrimarySource.Equals(musicLibrarySource))
{
Hyena.Log.DebugFormat("Updating file name for {0}", track);
renamed = RenameFile(track);
if (renamed && !wrote)
{
track.LastSyncedStamp = DateTime.Now;
}
}
} catch (Exception) {
Hyena.Log.ErrorFormat("Error writing to or renaming {0}", track);
} finally {
if (wrote || renamed)
{
// Save the resulting changes to FileSize, LastSyncedStamp, possibly to Uri, etc
// Clear track model caches if URI changed
track.Save(renamed);
}
else
{
if (update_synced_at == null)
{
update_synced_at = new HyenaSqliteCommand(
"UPDATE CoreTracks SET LastSyncedStamp = ? WHERE TrackID = ?");
}
ServiceManager.DbConnection.Execute(update_synced_at, DateTime.Now, track.TrackId);
}
}
}
public virtual void UpdateUnfilteredAggregates()
{
HyenaSqliteCommand count_command = new HyenaSqliteCommand(String.Format(
"SELECT COUNT(*), SUM(CoreTracks.FileSize) {0}", UnfilteredQuery
));
using (HyenaDataReader reader = new HyenaDataReader(connection.Query(count_command))) {
count = reader.Get <long> (0);
filesize = reader.Get <long> (1);
}
}
public TrackSyncPipelineElement(PrimarySource psource, DateTime scan_started) : base()
{
this.psource = psource;
this.scan_started = scan_started;
fetch_command = DatabaseTrackInfo.Provider.CreateFetchCommand(
"CoreTracks.PrimarySourceID = ? AND CoreTracks.Uri = ? LIMIT 1");
fetch_similar_command = DatabaseTrackInfo.Provider.CreateFetchCommand(
"CoreTracks.PrimarySourceID = ? AND CoreTracks.LastSyncedStamp < ? AND CoreTracks.MetadataHash = ?");
}
protected DatabaseTrackInfo GetTrack(HyenaSqliteCommand cmd, params object [] args)
{
using (var reader = ServiceManager.DbConnection.Query(cmd, args)) {
if (reader.Read())
{
return(DatabaseTrackInfo.Provider.Load(reader));
}
}
return(null);
}
private void Create()
{
HyenaSqliteCommand command = new HyenaSqliteCommand(
@"INSERT INTO LastfmStations (Creator, Name, Type, Arg, PlayCount)
VALUES (?, ?, ?, ?, ?)",
lastfm.Account.UserName, Name,
Type.ToString(), Arg, PlayCount
);
dbid = ServiceManager.DbConnection.Execute(command);
TypeUniqueId = dbid.ToString();
}
public TrackSyncPipelineElement(PrimarySource psource, DateTime scan_started) : base()
{
this.psource = psource;
this.scan_started = scan_started;
fetch_command = DatabaseTrackInfo.Provider.CreateFetchCommand(String.Format(
"CoreTracks.PrimarySourceID = ? AND {0} = ? LIMIT 1",
Banshee.Query.BansheeQuery.UriField.Column));
fetch_similar_command = DatabaseTrackInfo.Provider.CreateFetchCommand(
"CoreTracks.PrimarySourceID = ? AND CoreTracks.LastSyncedStamp < ? AND CoreTracks.MetadataHash = ?");
}
public void SetModelAndCache(DatabaseTrackListModel model, IDatabaseTrackModelCache cache)
{
if (Model != model)
{
Model = model;
Cache = cache;
Reset();
OnModelAndCacheUpdated();
}
shuffler_query = null;
}
public virtual void UpdateUnfilteredAggregates()
{
HyenaSqliteCommand count_command = new HyenaSqliteCommand(String.Format(
"SELECT COUNT(*), SUM({0}), SUM({1}) {2}",
BansheeQuery.FileSizeField.Column, BansheeQuery.DurationField.Column, UnfilteredQuery
));
using (HyenaDataReader reader = new HyenaDataReader(connection.Query(count_command))) {
count = reader.Get <long> (0);
filesize = reader.Get <long> (1);
duration = reader.Get <TimeSpan> (2);
}
}
private void AddTrack(string track)
{
import_manager.ImportTrack(track);
// Trigger file rename.
string uri = new SafeUri(track).AbsoluteUri;
HyenaSqliteCommand command = new HyenaSqliteCommand(@"
UPDATE CoreTracks
SET DateUpdatedStamp = LastSyncedStamp + 1
WHERE Uri = ?", uri);
ServiceManager.DbConnection.Execute(command);
}
protected override void AddTrackRange(DatabaseTrackListModel from, RangeCollection.Range range)
{
last_add_range_command = (!from.CachesJoinTableEntries)
? add_track_range_command
: from == last_add_range_from_model
? last_add_range_command
: new HyenaSqliteCommand(String.Format(add_track_range_from_joined_model_sql, from.JoinTable, from.JoinPrimaryKey));
long first_order_id = ServiceManager.DbConnection.Query <long> ("SELECT OrderID FROM CoreCache WHERE ModelID = ? LIMIT 1 OFFSET ?", from.CacheId, range.Start);
ServiceManager.DbConnection.Execute(last_add_range_command, DbId, MaxViewOrder - first_order_id, from.CacheId, range.Start, range.Count);
last_add_range_from_model = from;
}
private void AddTrack(string track)
{
import_manager.ImportTrack(track);
// Trigger file rename.
string uri = new SafeUri(track).AbsoluteUri;
var command = new HyenaSqliteCommand(String.Format(@"
UPDATE CoreTracks
SET DateUpdatedStamp = LastSyncedStamp + 1
WHERE {0} = ?",
BansheeQuery.UriField.Column), uri);
ServiceManager.DbConnection.Execute(command);
}
private void Select <T> (T val)
{
T res = default(T);
var cmd = new HyenaSqliteCommand("SELECT ?", val);
Log.DebugFormat("Select<T> cmd is {0}", cmd.Text);
var db = ServiceManager.DbConnection;
for (int i = 0; i < NUM * 250; i++)
{
res = db.Query <T> (cmd);
}
Assert.AreEqual(val, res);
}
public SaveTrackMetadataJob() : base(Catalog.GetString("Saving Metadata to File"))
{
SetResources(Resource.Cpu, Resource.Disk, Resource.Database);
IsBackground = true;
CountCommand = new HyenaSqliteCommand(
"SELECT COUNT(*) FROM CoreTracks WHERE DateUpdatedStamp > LastSyncedStamp AND PrimarySourceID = ?",
source.DbId
);
SelectCommand = DatabaseTrackInfo.Provider.CreateFetchCommand(String.Format(
"DateUpdatedStamp > LastSyncedStamp AND PrimarySourceID = {0}", source.DbId)
);
}
private static int Execute(HyenaSqliteCommand command)
{
int result = -1;
try {
result = Convert.ToInt32(db.Execute(command));
}
catch (OverflowException e)
{
Log.Exception(String.Format("Updater.Execute failed. ({0})", command), e);
throw;
}
return(result);
}
private void Update()
{
HyenaSqliteCommand command = new HyenaSqliteCommand(
@"UPDATE LastfmStations
SET Name = ?, Type = ?, Arg = ?, PlayCount = ?
WHERE StationID = ?",
Name, Type.ToString(), Arg, PlayCount, dbid
);
ServiceManager.DbConnection.Execute(command);
Station = Type.GetStationFor(Arg);
OnUpdated();
}
// Commented out for now - this method doesn't handle actually subscribing to the feeds
// (the most important task in migrating podcasts), and it looks like it imports podcast files
// into the Music Library.
/*private void ImportPodcasts(LibraryImportManager manager, XmlNodeList podcasts)
* {
* foreach (XmlElement entry in podcasts) {
* if (CheckForCanceled ()) {
* break;
* }
*
* processed++;
*
* string title = String.Empty, feed = String.Empty;
* SafeUri uri = null;
*
* foreach (XmlElement child in entry.ChildNodes) {
* if (child == null || child.InnerText == null || child.InnerText == String.Empty) {
* continue;
* }
*
* try {
* switch (child.Name) {
* case "title":
* title = child.InnerText;
* break;
* case "album":
* feed = child.InnerText;
* break;
* case "mountpoint":
* uri = new SafeUri (child.InnerText);
* break;
* }
* } catch (Exception) {
* // parsing InnerText failed
* }
* }
*
* if (uri == null) {
* continue;
* }
*
* UpdateUserJob (processed, count, "", title);
*
* try {
* DatabaseTrackInfo track = manager.ImportTrack (uri);
*
* if (track == null) {
* LogError (SafeUri.UriToFilename (uri), Catalog.GetString ("Unable to import podcast."));
* continue;
* }
*
* track.TrackTitle = title;
* track.AlbumTitle = feed;
* track.Genre = "Podcast";
*
* track.Save (false);
* } catch (Exception e) {
* LogError (SafeUri.UriToFilename (uri), e);
* }
* }
* }*/
private void ImportStaticPlaylists(XmlNodeList playlists)
{
foreach (XmlElement list in playlists)
{
if (CheckForCanceled())
{
break;
}
processed++;
try {
string title = String.Empty;
if (list.HasAttribute("name"))
{
title = list.GetAttribute("name");
}
UpdateUserJob(processed, count, "", title);
PlaylistSource playlist = new PlaylistSource(title, ServiceManager.SourceManager.MusicLibrary);
playlist.Save();
ServiceManager.SourceManager.MusicLibrary.AddChildSource(playlist);
HyenaSqliteCommand insert_command = new HyenaSqliteCommand(String.Format(
@"INSERT INTO CorePlaylistEntries (PlaylistID, TrackID) VALUES ({0}, ?)", playlist.DbId));
foreach (XmlElement entry in list.ChildNodes)
{
if (entry.Name != "location")
{
continue;
}
int track_id = ServiceManager.SourceManager.MusicLibrary.GetTrackIdForUri(entry.InnerText);
if (track_id > 0)
{
ServiceManager.DbConnection.Execute(insert_command, track_id);
}
}
playlist.Reload();
playlist.NotifyUser();
} catch (Exception e) {
LogError("", e);
}
}
}
public RecentAlbumsList(int maxCount)
{
max_count = maxCount;
select_cmd = new HyenaSqliteCommand(@"
SELECT a.AlbumID, a.Title, a.ArtistName, a.IsCompilation, MAX(t.LastPlayedStamp) as MaxLastPlayed
FROM CoreAlbums a, CoreTracks t
WHERE t.PrimarySourceID = ? AND a.AlbumID = t.AlbumID AND a.Title != ''
GROUP BY a.AlbumID
ORDER BY MaxLastPlayed DESC
LIMIT ?");
Reload();
ServiceManager.PlaybackController.TrackStarted += (o, a) => Reload();
}
public CoverArtJob(DateTime lastScan) : base(Catalog.GetString("Downloading Cover Art"))
{
last_scan = lastScan;
// Since we do last_scan - retry_every, avoid out-of-range error by ensuring
// the last_scan date isn't already MinValue
if (last_scan == DateTime.MinValue)
{
last_scan = DateTime.Now - TimeSpan.FromDays(365 * 50);
}
CountCommand = new HyenaSqliteCommand(@"
SELECT count(DISTINCT CoreTracks.AlbumID)
FROM CoreTracks, CoreArtists, CoreAlbums
WHERE
CoreTracks.PrimarySourceID = ? AND
CoreTracks.DateUpdatedStamp > ? AND
CoreTracks.AlbumID = CoreAlbums.AlbumID AND
CoreAlbums.ArtistID = CoreArtists.ArtistID AND
CoreTracks.AlbumID NOT IN (
SELECT AlbumID FROM CoverArtDownloads WHERE
LastAttempt > ? OR Downloaded = 1)",
ServiceManager.SourceManager.MusicLibrary.DbId, last_scan, last_scan - retry_every
);
SelectCommand = new HyenaSqliteCommand(String.Format(@"
SELECT DISTINCT CoreAlbums.AlbumID, CoreAlbums.Title, CoreArtists.Name, {0}, CoreTracks.TrackID
FROM CoreTracks, CoreArtists, CoreAlbums
WHERE
CoreTracks.PrimarySourceID = ? AND
CoreTracks.DateUpdatedStamp > ? AND
CoreTracks.AlbumID = CoreAlbums.AlbumID AND
CoreAlbums.ArtistID = CoreArtists.ArtistID AND
CoreTracks.AlbumID NOT IN (
SELECT AlbumID FROM CoverArtDownloads WHERE
LastAttempt > ? OR Downloaded = 1)
GROUP BY CoreTracks.AlbumID ORDER BY CoreTracks.DateUpdatedStamp DESC LIMIT ?",
Banshee.Query.BansheeQuery.UriField.Column),
ServiceManager.SourceManager.MusicLibrary.DbId, last_scan, last_scan - retry_every, 1
);
SetResources(Resource.Database);
PriorityHints = PriorityHints.LongRunning;
IsBackground = true;
CanCancel = true;
DelayShow = true;
}
public DatabaseConfigurationClient(BansheeDbConnection connection)
{
this.connection = connection;
select_value_command = new HyenaSqliteCommand(String.Format(
"SELECT Value FROM {0} WHERE Key=?", TableName));
select_id_command = new HyenaSqliteCommand(String.Format(
"SELECT EntryID FROM {0} WHERE Key=?", TableName));
insert_command = new HyenaSqliteCommand(String.Format(
"INSERT INTO {0} (EntryID, Key, Value) VALUES (NULL, ?, ?)", TableName));
update_command = new HyenaSqliteCommand(String.Format(
"UPDATE {0} SET Value=? WHERE Key=?", TableName));
}
