public static IDatabaseSet <T> Set <T>(this IDatabase database, ITransactionSource transaction = null)
{
#pragma warning disable 612, 618
return(database.Set <T>(database.Config.Table <T>(), null, transaction));
#pragma warning restore 612, 618
}
private static IDatabaseCommand CreateCommand(IDatabaseComponent database, ITransactionSource transaction)
{
var query = database.QueryFactory.Build();
query.Add.AddColumn(database.Tables.LibraryItem.Column("DirectoryName"));
query.Add.AddColumn(database.Tables.LibraryItem.Column("FileName"));
query.Add.AddColumn(database.Tables.LibraryItem.Column("ImportDate"));
query.Add.AddColumn(database.Tables.LibraryItem.Column("Status"));
query.Add.AddColumn(database.Tables.LibraryItem.Column("Flags"));
query.Add.SetTable(database.Tables.LibraryItem);
query.Output.AddParameter("DirectoryName", DbType.String, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
query.Output.AddParameter("FileName", DbType.String, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
query.Output.AddParameter("ImportDate", DbType.String, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
query.Output.AddParameter("Status", DbType.Byte, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
query.Output.AddParameter("Flags", DbType.Byte, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
query.Filter.Expressions.Add(
query.Filter.CreateUnary(
QueryOperator.Not,
query.Filter.CreateFunction(
QueryFunction.Exists,
query.Filter.CreateSubQuery(
database.QueryFactory.Build().With(subQuery =>
{
subQuery.Output.AddOperator(QueryOperator.Star);
subQuery.Source.AddTable(database.Tables.LibraryItem);
subQuery.Filter.AddColumn(database.Tables.LibraryItem.Column("FileName"));
})
)
)
)
);
return(database.CreateCommand(query.Build(), DatabaseCommandFlags.NoCache, transaction));
}
protected Transaction(ITransactionSource transactionSource)
{
if (transactionSource == null)
{
throw new ArgumentNullException("transactionSource");
}
this.transactionSource = transactionSource;
}
public override IEnumerable <string> GetTableNames(ITransactionSource transaction = null)
{
if (this.TableNames == null)
{
var query = this.Database.QueryFactory.Create("SELECT TABLE_NAME FROM information_schema.tables");
using (var reader = this.Database.ExecuteReader(query, transaction))
{
this.TableNames = reader.Select(element => element.Get <string>("TABLE_NAME")).ToArray();
}
}
return(this.TableNames);
}
public override IEnumerable <string> GetTableNames(ITransactionSource transaction = null)
{
if (this.TableNames == null)
{
var query = this.Database.QueryFactory.Create("SELECT name FROM sqlite_master WHERE type = 'table'");
using (var reader = this.Database.ExecuteReader(query, transaction))
{
this.TableNames = reader.Select(element => element.Get <string>("name")).ToArray();
}
}
return(this.TableNames);
}
private IQueryable <LibraryItem> GetItems(LibraryItemStatus?status, ITransactionSource transaction)
{
var queryable = this.Database.AsQueryable <LibraryItem>(transaction);
if (!status.HasValue)
{
return(queryable.Where(libraryItem => libraryItem.MetaDatas.Any()));
}
else
{
return(queryable.Where(libraryItem => libraryItem.Status == status.Value && libraryItem.MetaDatas.Any()));
}
}
public Task Clear(LibraryItemStatus libraryItemStatus, ITransactionSource transaction)
{
return(this.Database.ExecuteAsync(this.Database.Queries.RemoveLibraryVariousArtists, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["name"] = CustomMetaData.VariousArtists;
parameters["type"] = MetaDataItemType.Tag;
parameters["status"] = libraryItemStatus;
break;
}
}, transaction));
}
private static IDatabaseCommand CreateCommand(IDatabaseComponent database, ITransactionSource transaction)
{
var query = database.QueryFactory.Build();
query.Add.SetTable(database.Tables.PlaylistItem);
query.Add.AddColumns(database.Tables.PlaylistItem.Columns.Except(database.Tables.PlaylistItem.PrimaryKeys));
query.Output.AddSubQuery(database.QueryFactory.Build().With(subQuery =>
{
subQuery.Output.AddColumn(database.Tables.LibraryItem.Column("Id"));
subQuery.Source.AddTable(database.Tables.LibraryItem);
subQuery.Filter.AddColumn(database.Tables.LibraryItem.Column("FileName"));
}));
query.Output.AddParameters(database.Tables.PlaylistItem.Columns.Except(database.Tables.PlaylistItem.PrimaryKeys.Concat(database.Tables.PlaylistItem.Column("LibraryItem_Id"))));
return(database.CreateCommand(query.Build(), DatabaseCommandFlags.NoCache, transaction));
}
public Task Populate(PlaylistItemStatus playlistItemStatus, ITransactionSource transaction)
{
return(this.Database.ExecuteAsync(this.Database.Queries.UpdatePlaylistVariousArtists, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["name"] = CustomMetaData.VariousArtists;
parameters["type"] = MetaDataItemType.Tag;
parameters["value"] = bool.TrueString;
parameters["status"] = playlistItemStatus;
break;
}
}, transaction));
}
private async Task AddPlaylistItems(IDatabaseQuery query, ITransactionSource transaction)
{
var count = await this.Database.ExecuteScalarAsync <int>(query, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["playlistId"] = this.Playlist.Id;
parameters["sequence"] = this.Sequence;
parameters["status"] = PlaylistItemStatus.Import;
break;
}
}, transaction).ConfigureAwait(false);
this.Sequence += count;
this.Offset += count;
}
public override IEnumerable <string> GetColumnNames(string tableName, ITransactionSource transaction = null)
{
var columnNames = default(string[]);
if (!this.ColumnNames.TryGetValue(tableName, out columnNames))
{
var query = this.Database.QueryFactory.Create(string.Format("SELECT COLUMN_NAME FROM information_schema.columns WHERE TABLE_NAME = '{0}'", tableName));
using (var reader = this.Database.ExecuteReader(query, transaction))
{
columnNames = reader.Select(element => element.Get <string>("COLUMN_NAME")).ToArray();
if (columnNames.Length == 0)
{
throw new InvalidOperationException(string.Format("No columns were found for table \"{0}\".", tableName));
}
if (!this.ColumnNames.TryAdd(tableName, columnNames))
{
//TODO: Warn?
}
}
}
return(columnNames);
}
public static IDatabaseQuerySource Source <T>(this IDatabase database, ITransactionSource transaction = null)
{
return(database.Source <T>(null, transaction));
}
public static IDatabaseSet <T> Set <T>(this IDatabase database, ITableConfig table, DatabaseParameterHandler parameters, ITransactionSource transaction = null)
{
return(database.Set <T>(database.Source(table, parameters, transaction)));
}
public static IDatabaseSet <T> Set <T>(this IDatabase database, ITableConfig table, ITransactionSource transaction = null)
{
return(database.Set <T>(table, null, transaction));
}
public static IDatabaseQuerySource Source(this IDatabase database, IDatabaseQueryComposer composer, DatabaseParameterHandler parameters, ITransactionSource transaction = null)
{
return(database.Source(composer, parameters, transaction));
}
public static Task RemovePlaylistItems(IDatabaseComponent database, int playlistId, PlaylistItemStatus status, ITransactionSource transaction)
{
return(database.ExecuteAsync(database.Queries.RemovePlaylistItems, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["playlistId"] = playlistId;
parameters["status"] = status;
break;
}
}, transaction));
}
public static Task UpdatePlaylistItem(IDatabaseComponent database, PlaylistItem playlistItem, ITransactionSource transaction)
{
var table = database.Tables.PlaylistItem;
var builder = database.QueryFactory.Build();
builder.Update.SetTable(table);
builder.Update.AddColumns(table.UpdatableColumns);
builder.Filter.AddColumns(table.PrimaryKeys);
var query = builder.Build();
var parameters = new ParameterHandlerStrategy(table, playlistItem).Handler;
return(database.ExecuteAsync(query, parameters, transaction));
}
public static Task RemoveHierarchies(IDatabaseComponent database, LibraryItemStatus?status, ITransactionSource transaction)
{
return(RemoveHierarchies(database, null, status, transaction));
}
public static Task <int> ExecuteAsync(this IDatabase database, IQueryGraphBuilder query, DatabaseParameterHandler parameters, ITransactionSource transaction = null)
{
return(database.ExecuteAsync(query.Build(), parameters, transaction));
}
public static int Execute(this IDatabase database, IDatabaseQuery query, ITransactionSource transaction = null)
{
return(database.Execute(query, null, transaction));
}
protected Transaction(ITransactionSource transactionSource)
{
if (transactionSource == null)
throw new ArgumentNullException ("transactionSource");
this.transactionSource = transactionSource;
}
public static Task <int> ExecuteAsync(this IDatabase database, IQueryGraphBuilder query, ITransactionSource transaction = null)
{
return(database.ExecuteAsync(query, null, transaction));
}
public static Task <T> ExecuteScalarAsync <T>(this IDatabase database, IDatabaseQuery query, ITransactionSource transaction = null)
{
return(database.ExecuteScalarAsync <T>(query, null, transaction));
}
private async Task AddHiearchies(LibraryItemStatus?status, CancellationToken cancellationToken, ITransactionSource transaction)
{
using (var libraryHierarchyPopulator = new LibraryHierarchyPopulator(this.Database, this.Visible, transaction))
{
libraryHierarchyPopulator.InitializeComponent(this.Core);
await this.WithSubTask(libraryHierarchyPopulator,
() => libraryHierarchyPopulator.Populate(status, cancellationToken)
).ConfigureAwait(false);
}
}
public static IDatabaseReader ExecuteReader(this IDatabase database, IQueryGraphBuilder query, ITransactionSource transaction = null)
{
return(database.ExecuteReader(query, null, transaction));
}
public static Task RemoveHierarchies(IDatabaseComponent database, LibraryHierarchy libraryHierarchy, LibraryItemStatus?status, ITransactionSource transaction)
{
return(database.ExecuteAsync(database.Queries.RemoveLibraryHierarchyItems, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
if (libraryHierarchy != null)
{
parameters["libraryHierarchyId"] = libraryHierarchy.Id;
}
if (status.HasValue)
{
parameters["status"] = status;
}
break;
}
}, transaction));
}
public static IDatabaseQuerySource Source(this IDatabase database, ITableConfig table, ITransactionSource transaction = null)
{
return(database.Source(table, null, transaction));
}
public static async Task UpdatePlaylistItem(IDatabaseComponent database, int playlistItemId, Action <PlaylistItem> action, ITransactionSource transaction)
{
var table = database.Tables.PlaylistItem;
var builder = database.QueryFactory.Build();
builder.Output.AddColumns(table.Columns);
builder.Source.AddTable(table);
builder.Filter.AddColumns(table.PrimaryKeys);
var query = builder.Build();
var playlistItem = default(PlaylistItem);
using (var sequence = database.ExecuteAsyncEnumerator <PlaylistItem>(query, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters[table.PrimaryKey] = playlistItemId;
break;
}
}, transaction))
{
if (await sequence.MoveNextAsync().ConfigureAwait(false))
{
playlistItem = sequence.Current;
}
}
action(playlistItem);
await UpdatePlaylistItem(database, playlistItem, transaction).ConfigureAwait(false);
}
public static IDatabaseQuerySource Source(this IDatabase database, ITableConfig table, DatabaseParameterHandler parameters, ITransactionSource transaction = null)
{
return(database.Source(new EntityRelationQueryComposer(database, table), parameters, transaction));
}
public IEnumerable <IColumnConfig> GetColumns(IDatabase database, ITableConfig table, ITransactionSource transaction = null)
{
var properties = new EntityPropertyEnumerator(table.TableType);
var columns = new List <IColumnConfig>();
foreach (var property in properties)
{
if (!ColumnValidator.Validate(database, property))
{
continue;
}
var column = Factories.Column.Create(table, ColumnConfig.By(property));
if (!ColumnValidator.Validate(database, table, column, transaction))
{
continue;
}
columns.Add(column);
}
return(columns);
}
public static IDatabaseQuerySource Source(this IDatabase database, IDatabaseQueryComposer composer, ITransactionSource transaction = null)
{
return(database.Source(composer, null, transaction));
}
