MyFavMirrors/owntone-server
1
0
Fork 0
mirror of https://github.com/owntone/owntone-server.git synced 2025-01-01 10:03:24 -05:00
Code Issues Packages Projects Releases Wiki Activity
d94cf3f07f
owntone-server/src/db.c

7150 lines
174 KiB
C
Raw Normal View History

Add new database code
2009-06-07 12:56:35 -04:00
/*
Trim metadata strings on files INSERT/UPDATE
2011-03-08 12:54:20 -05:00
* Copyright (C) 2009-2011 Julien BLACHE <jb@jblache.org>
Introduce DAAP-specific collation function for SQLite
2010-08-29 04:21:35 -04:00
* Copyright (C) 2010 Kai Elwert <elwertk@googlemail.com>
Add new database code
2009-06-07 12:56:35 -04:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdint.h>
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
#include <stdbool.h>
Add new database code
2009-06-07 12:56:35 -04:00
#include <inttypes.h>
Introduce DAAP-specific collation function for SQLite
2010-08-29 04:21:35 -04:00
#include <errno.h>
Handle database upgrade v11 -> v12
2011-03-15 16:26:17 -04:00
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
#include <unictype.h>
#include <uninorm.h>
#include <unistr.h>
Handle database upgrade v11 -> v12
2011-03-15 16:26:17 -04:00
#include <sys/mman.h>
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
#include <limits.h>
Handle database upgrade v11 -> v12
2011-03-15 16:26:17 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
#include <sqlite3.h>
Make database location a configuration item
2010-03-21 06:33:05 -04:00
#include "conffile.h"
Add new database code
2009-06-07 12:56:35 -04:00
#include "logger.h"
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
#include "cache.h"
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
#include "listener.h"
[library] Move library update trigger to new library module
2017-01-27 17:23:25 -05:00
#include "library.h"
Move daap_songalbumid() to its now-unique callsite
2010-03-06 11:21:54 -05:00
#include "misc.h"
Add new database code
2009-06-07 12:56:35 -04:00
#include "db.h"
[db] Move initialization of new db into its own file (db_init.c)
2016-11-04 02:10:36 -04:00
#include "db_init.h"
[db] Move database upgrade logic to separate file
2015-12-19 01:51:10 -05:00
#include "db_upgrade.h"
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
#include "rng.h"
Add new database code
2009-06-07 12:56:35 -04:00
#define STR(x) ((x) ? (x) : "")
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
// Inotify cookies are uint32_t
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
#define INOTIFY_FAKE_COOKIE ((int64_t)1 << 32)
Add new database code
2009-06-07 12:56:35 -04:00
[db] Fix integer overflow in bind_mfi (ref issue #683) Also drop DB_TYPE_CHAR since it's not really being used.
2019-01-30 17:34:00 -05:00
#define DB_TYPE_INT 1
#define DB_TYPE_INT64 2
#define DB_TYPE_STRING 3
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
// Flags that the field will not be bound to prepared statements, which is relevant if the field has no
// matching column, or if the the column value is set automatically by the db, e.g. by a trigger
#define DB_FLAG_NO_BIND (1 << 0)
[db] Don't zero play_count, skip_count, seek, time_played, time_skipped on update If a file gets updated/rescanned we generally don't want to reset the above values. This commit adds DB_FLAG_NO_ZERO, which marks a field so that db_file_update() will only update it if the new value is non-zero (i.e. the caller probably has a "better" value).
2018-12-30 15:55:55 -05:00
// Flags that we will only update column value if we have non-zero value (to avoid zeroing e.g. rating)
#define DB_FLAG_NO_ZERO (1 << 1)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
// The two last columns of playlist_info are calculated fields, so all playlist retrieval functions must use this query
#define Q_PL_SELECT "SELECT f.*, COUNT(pi.id), SUM(pi.filepath NOT NULL AND pi.filepath LIKE 'http%%')" \
" FROM playlists f LEFT JOIN playlistitems pi ON (f.id = pi.playlistid)"
Make album groups persistent Store groups (only album groups supported at the moment) in the DB, so their ids are persistent for the duration of the forked-daapd session. Those ids are used to, among other things, retrieve artwork, so we must provide ourselves some persistence here. This brings us to schema version 8.
2010-03-06 12:56:30 -05:00
enum group_type {
G_ALBUMS = 1,
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
G_ARTISTS = 2,
Make album groups persistent Store groups (only album groups supported at the moment) in the DB, so their ids are persistent for the duration of the forked-daapd session. Those ids are used to, among other things, retrieve artwork, so we must provide ourselves some persistence here. This brings us to schema version 8.
2010-03-06 12:56:30 -05:00
};
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
enum fixup_type {
DB_FIXUP_STANDARD = 0,
DB_FIXUP_NO_SANITIZE,
DB_FIXUP_TITLE,
DB_FIXUP_ARTIST,
DB_FIXUP_ALBUM,
DB_FIXUP_ALBUM_ARTIST,
DB_FIXUP_GENRE,
DB_FIXUP_COMPOSER,
DB_FIXUP_TYPE,
DB_FIXUP_CODECTYPE,
DB_FIXUP_MEDIA_KIND,
[db] Transfer some library tag fixup to the db's generic fixup Transfer setting defaults for media_kind and item_kind. Also sets default media_kind for queue_items.
2018-12-30 10:13:57 -05:00
DB_FIXUP_ITEM_KIND,
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
DB_FIXUP_TITLE_SORT,
DB_FIXUP_ARTIST_SORT,
DB_FIXUP_ALBUM_SORT,
DB_FIXUP_ALBUM_ARTIST_SORT,
DB_FIXUP_COMPOSER_SORT,
DB_FIXUP_TIME_MODIFIED,
[db] Move calculation of artist/album id's from sqlite to code The purpose of this is to support library backends making their own calculation of these id's, which is relevant if they have more information available than just album_artist and album. This also removes a bunch of sqlite extension code plus some triggers, which in itself is probably an improvement.
2019-05-12 17:28:38 -04:00
DB_FIXUP_SONGARTISTID,
DB_FIXUP_SONGALBUMID,
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
};
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
struct db_unlock {
int proceed;
pthread_cond_t cond;
pthread_mutex_t lck;
};
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
struct db_statements
{
sqlite3_stmt *files_insert;
sqlite3_stmt *files_update;
sqlite3_stmt *files_ping;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
sqlite3_stmt *playlists_insert;
sqlite3_stmt *playlists_update;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
};
Add new database code
2009-06-07 12:56:35 -04:00
struct col_type_map {
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
char *name;
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
size_t offset;
Add new database code
2009-06-07 12:56:35 -04:00
short type;
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
enum fixup_type fixup;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
short flag;
Add new database code
2009-06-07 12:56:35 -04:00
};
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
struct fixup_ctx
{
const struct col_type_map *map;
size_t map_size;
void *data;
struct media_file_info *mfi;
struct playlist_info *pli;
struct db_queue_item *queue_item;
};
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
struct query_clause {
char *where;
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
char *group;
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
char *having;
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
char *order;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *index;
};
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
struct browse_clause {
char *select;
char *where;
char *group;
};
Add new database code
2009-06-07 12:56:35 -04:00
/* This list must be kept in sync with
Rename the songs table
2009-06-11 17:03:53 -04:00
* - the order of the columns in the files table
Add new database code
2009-06-07 12:56:35 -04:00
* - the type and name of the fields in struct media_file_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const struct col_type_map mfi_cols_map[] =
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "id", mfi_offsetof(id), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_BIND },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "path", mfi_offsetof(path), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "virtual_path", mfi_offsetof(virtual_path), DB_TYPE_STRING },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "fname", mfi_offsetof(fname), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "directory_id", mfi_offsetof(directory_id), DB_TYPE_INT },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "title", mfi_offsetof(title), DB_TYPE_STRING, DB_FIXUP_TITLE },
{ "artist", mfi_offsetof(artist), DB_TYPE_STRING, DB_FIXUP_ARTIST },
{ "album", mfi_offsetof(album), DB_TYPE_STRING, DB_FIXUP_ALBUM },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "album_artist", mfi_offsetof(album_artist), DB_TYPE_STRING, DB_FIXUP_ALBUM_ARTIST },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "genre", mfi_offsetof(genre), DB_TYPE_STRING, DB_FIXUP_GENRE },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "comment", mfi_offsetof(comment), DB_TYPE_STRING },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "type", mfi_offsetof(type), DB_TYPE_STRING, DB_FIXUP_TYPE },
{ "composer", mfi_offsetof(composer), DB_TYPE_STRING, DB_FIXUP_COMPOSER },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "orchestra", mfi_offsetof(orchestra), DB_TYPE_STRING },
{ "conductor", mfi_offsetof(conductor), DB_TYPE_STRING },
{ "grouping", mfi_offsetof(grouping), DB_TYPE_STRING },
{ "url", mfi_offsetof(url), DB_TYPE_STRING },
{ "bitrate", mfi_offsetof(bitrate), DB_TYPE_INT },
{ "samplerate", mfi_offsetof(samplerate), DB_TYPE_INT },
{ "song_length", mfi_offsetof(song_length), DB_TYPE_INT },
{ "file_size", mfi_offsetof(file_size), DB_TYPE_INT64 },
{ "year", mfi_offsetof(year), DB_TYPE_INT },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "date_released", mfi_offsetof(date_released), DB_TYPE_INT },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "track", mfi_offsetof(track), DB_TYPE_INT },
{ "total_tracks", mfi_offsetof(total_tracks), DB_TYPE_INT },
{ "disc", mfi_offsetof(disc), DB_TYPE_INT },
{ "total_discs", mfi_offsetof(total_discs), DB_TYPE_INT },
{ "bpm", mfi_offsetof(bpm), DB_TYPE_INT },
[db] Fix integer overflow in bind_mfi (ref issue #683) Also drop DB_TYPE_CHAR since it's not really being used.
2019-01-30 17:34:00 -05:00
{ "compilation", mfi_offsetof(compilation), DB_TYPE_INT },
{ "artwork", mfi_offsetof(artwork), DB_TYPE_INT },
[db] Don't zero play_count, skip_count, seek, time_played, time_skipped on update If a file gets updated/rescanned we generally don't want to reset the above values. This commit adds DB_FLAG_NO_ZERO, which marks a field so that db_file_update() will only update it if the new value is non-zero (i.e. the caller probably has a "better" value).
2018-12-30 15:55:55 -05:00
{ "rating", mfi_offsetof(rating), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
{ "play_count", mfi_offsetof(play_count), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
{ "skip_count", mfi_offsetof(skip_count), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
{ "seek", mfi_offsetof(seek), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "data_kind", mfi_offsetof(data_kind), DB_TYPE_INT },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "media_kind", mfi_offsetof(media_kind), DB_TYPE_INT, DB_FIXUP_MEDIA_KIND },
[db] Transfer some library tag fixup to the db's generic fixup Transfer setting defaults for media_kind and item_kind. Also sets default media_kind for queue_items.
2018-12-30 10:13:57 -05:00
{ "item_kind", mfi_offsetof(item_kind), DB_TYPE_INT, DB_FIXUP_ITEM_KIND },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "description", mfi_offsetof(description), DB_TYPE_STRING },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "db_timestamp", mfi_offsetof(db_timestamp), DB_TYPE_INT },
[db] Fix for time_added incorrectly updated (issue #852)
2019-12-03 12:24:39 -05:00
{ "time_added", mfi_offsetof(time_added), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "time_modified", mfi_offsetof(time_modified), DB_TYPE_INT, DB_FIXUP_TIME_MODIFIED },
[db] Don't zero play_count, skip_count, seek, time_played, time_skipped on update If a file gets updated/rescanned we generally don't want to reset the above values. This commit adds DB_FLAG_NO_ZERO, which marks a field so that db_file_update() will only update it if the new value is non-zero (i.e. the caller probably has a "better" value).
2018-12-30 15:55:55 -05:00
{ "time_played", mfi_offsetof(time_played), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
{ "time_skipped", mfi_offsetof(time_skipped), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_ZERO },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "disabled", mfi_offsetof(disabled), DB_TYPE_INT },
{ "sample_count", mfi_offsetof(sample_count), DB_TYPE_INT64 },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "codectype", mfi_offsetof(codectype), DB_TYPE_STRING, DB_FIXUP_CODECTYPE },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "idx", mfi_offsetof(idx), DB_TYPE_INT },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "has_video", mfi_offsetof(has_video), DB_TYPE_INT },
{ "contentrating", mfi_offsetof(contentrating), DB_TYPE_INT },
{ "bits_per_sample", mfi_offsetof(bits_per_sample), DB_TYPE_INT },
{ "tv_series_name", mfi_offsetof(tv_series_name), DB_TYPE_STRING },
{ "tv_episode_num_str", mfi_offsetof(tv_episode_num_str), DB_TYPE_STRING },
{ "tv_network_name", mfi_offsetof(tv_network_name), DB_TYPE_STRING },
{ "tv_episode_sort", mfi_offsetof(tv_episode_sort), DB_TYPE_INT },
{ "tv_season_num", mfi_offsetof(tv_season_num), DB_TYPE_INT },
[db] Move calculation of artist/album id's from sqlite to code The purpose of this is to support library backends making their own calculation of these id's, which is relevant if they have more information available than just album_artist and album. This also removes a bunch of sqlite extension code plus some triggers, which in itself is probably an improvement.
2019-05-12 17:28:38 -04:00
{ "songartistid", mfi_offsetof(songartistid), DB_TYPE_INT64, DB_FIXUP_SONGARTISTID },
{ "songalbumid", mfi_offsetof(songalbumid), DB_TYPE_INT64, DB_FIXUP_SONGALBUMID },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "title_sort", mfi_offsetof(title_sort), DB_TYPE_STRING, DB_FIXUP_TITLE_SORT },
{ "artist_sort", mfi_offsetof(artist_sort), DB_TYPE_STRING, DB_FIXUP_ARTIST_SORT },
{ "album_sort", mfi_offsetof(album_sort), DB_TYPE_STRING, DB_FIXUP_ALBUM_SORT },
{ "album_artist_sort", mfi_offsetof(album_artist_sort), DB_TYPE_STRING, DB_FIXUP_ALBUM_ARTIST_SORT },
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
{ "composer_sort", mfi_offsetof(composer_sort), DB_TYPE_STRING, DB_FIXUP_COMPOSER_SORT },
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
{ "channels", mfi_offsetof(channels), DB_TYPE_INT },
Add new database code
2009-06-07 12:56:35 -04:00
};
/* This list must be kept in sync with
* - the order of the columns in the playlists table
* - the type and name of the fields in struct playlist_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const struct col_type_map pli_cols_map[] =
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "id", pli_offsetof(id), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_BIND },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "title", pli_offsetof(title), DB_TYPE_STRING, DB_FIXUP_TITLE },
{ "type", pli_offsetof(type), DB_TYPE_INT },
{ "query", pli_offsetof(query), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "db_timestamp", pli_offsetof(db_timestamp), DB_TYPE_INT },
{ "disabled", pli_offsetof(disabled), DB_TYPE_INT },
{ "path", pli_offsetof(path), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "idx", pli_offsetof(index), DB_TYPE_INT },
{ "special_id", pli_offsetof(special_id), DB_TYPE_INT },
{ "virtual_path", pli_offsetof(virtual_path), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "parent_id", pli_offsetof(parent_id), DB_TYPE_INT },
{ "directory_id", pli_offsetof(directory_id), DB_TYPE_INT },
{ "query_order", pli_offsetof(query_order), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "query_limit", pli_offsetof(query_limit), DB_TYPE_INT },
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "media_kind", pli_offsetof(media_kind), DB_TYPE_INT, DB_FIXUP_MEDIA_KIND },
Count playlist items on the fly
2009-06-11 12:28:01 -04:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
// Not in the database, but returned via the query's COUNT()/SUM()
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "items", pli_offsetof(items), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_BIND },
{ "streams", pli_offsetof(streams), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_BIND },
Add new database code
2009-06-07 12:56:35 -04:00
};
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
/* This list must be kept in sync with
* - the order of the columns in the queue table
* - the type and name of the fields in struct db_queue_item
*/
static const struct col_type_map qi_cols_map[] =
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "id", qi_offsetof(id), DB_TYPE_INT, DB_FIXUP_STANDARD, DB_FLAG_NO_BIND },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
{ "file_id", qi_offsetof(id), DB_TYPE_INT },
{ "pos", qi_offsetof(pos), DB_TYPE_INT },
{ "shuffle_pos", qi_offsetof(shuffle_pos), DB_TYPE_INT },
{ "data_kind", qi_offsetof(data_kind), DB_TYPE_INT },
{ "media_kind", qi_offsetof(media_kind), DB_TYPE_INT, DB_FIXUP_MEDIA_KIND },
{ "song_length", qi_offsetof(song_length), DB_TYPE_INT },
{ "path", qi_offsetof(path), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "virtual_path", qi_offsetof(virtual_path), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "title", qi_offsetof(title), DB_TYPE_STRING, DB_FIXUP_TITLE },
{ "artist", qi_offsetof(artist), DB_TYPE_STRING, DB_FIXUP_ARTIST },
{ "album_artist", qi_offsetof(album_artist), DB_TYPE_STRING, DB_FIXUP_ALBUM_ARTIST },
{ "album", qi_offsetof(album), DB_TYPE_STRING, DB_FIXUP_ALBUM },
{ "genre", qi_offsetof(genre), DB_TYPE_STRING, DB_FIXUP_GENRE },
{ "songalbumid", qi_offsetof(songalbumid), DB_TYPE_INT64 },
{ "time_modified", qi_offsetof(time_modified), DB_TYPE_INT },
{ "artist_sort", qi_offsetof(artist_sort), DB_TYPE_STRING, DB_FIXUP_ARTIST_SORT },
{ "album_sort", qi_offsetof(album_sort), DB_TYPE_STRING, DB_FIXUP_ALBUM_SORT },
{ "album_artist_sort", qi_offsetof(album_artist_sort), DB_TYPE_STRING, DB_FIXUP_ALBUM_ARTIST_SORT },
{ "year", qi_offsetof(year), DB_TYPE_INT },
{ "track", qi_offsetof(track), DB_TYPE_INT },
{ "disc", qi_offsetof(disc), DB_TYPE_INT },
{ "artwork_url", qi_offsetof(artwork_url), DB_TYPE_STRING, DB_FIXUP_NO_SANITIZE },
{ "queue_version", qi_offsetof(queue_version), DB_TYPE_INT },
{ "composer", qi_offsetof(composer), DB_TYPE_STRING, DB_FIXUP_COMPOSER },
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
{ "songartistid", qi_offsetof(songartistid), DB_TYPE_INT64 },
[db] schema v20.01 support codec type/bitrate/samplerate in queue tbl
2019-06-04 16:51:44 -04:00
{ "type", qi_offsetof(type), DB_TYPE_STRING, DB_FIXUP_CODECTYPE },
{ "bitrate", qi_offsetof(bitrate), DB_TYPE_INT },
{ "samplerate", qi_offsetof(samplerate), DB_TYPE_INT },
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "channels", qi_offsetof(channels), DB_TYPE_INT },
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
};
Add new database code
2009-06-07 12:56:35 -04:00
/* This list must be kept in sync with
Rename the songs table
2009-06-11 17:03:53 -04:00
* - the order of the columns in the files table
Add new database code
2009-06-07 12:56:35 -04:00
* - the name of the fields in struct db_media_file_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const ssize_t dbmfi_cols_map[] =
Add new database code
2009-06-07 12:56:35 -04:00
{
dbmfi_offsetof(id),
dbmfi_offsetof(path),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(virtual_path),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(fname),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(directory_id),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(title),
dbmfi_offsetof(artist),
dbmfi_offsetof(album),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(album_artist),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(genre),
dbmfi_offsetof(comment),
dbmfi_offsetof(type),
dbmfi_offsetof(composer),
dbmfi_offsetof(orchestra),
dbmfi_offsetof(conductor),
dbmfi_offsetof(grouping),
dbmfi_offsetof(url),
dbmfi_offsetof(bitrate),
dbmfi_offsetof(samplerate),
dbmfi_offsetof(song_length),
dbmfi_offsetof(file_size),
dbmfi_offsetof(year),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(date_released),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(track),
dbmfi_offsetof(total_tracks),
dbmfi_offsetof(disc),
dbmfi_offsetof(total_discs),
dbmfi_offsetof(bpm),
dbmfi_offsetof(compilation),
Add artwork field to db (upgrade to v15). Set field when embedded artwork found by the filescanner. Reenable support for embedded artwork in group requests.
2014-01-11 17:05:29 -05:00
dbmfi_offsetof(artwork),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(rating),
dbmfi_offsetof(play_count),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(skip_count),
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
dbmfi_offsetof(seek),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(data_kind),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(media_kind),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(item_kind),
dbmfi_offsetof(description),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(db_timestamp),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(time_added),
dbmfi_offsetof(time_modified),
dbmfi_offsetof(time_played),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(time_skipped),
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi_offsetof(disabled),
dbmfi_offsetof(sample_count),
dbmfi_offsetof(codectype),
dbmfi_offsetof(idx),
dbmfi_offsetof(has_video),
dbmfi_offsetof(contentrating),
dbmfi_offsetof(bits_per_sample),
Add TV metadata to the database With this, we're bumping SCHEMA_VERSION to 2.
2009-12-26 02:39:39 -05:00
dbmfi_offsetof(tv_series_name),
dbmfi_offsetof(tv_episode_num_str),
dbmfi_offsetof(tv_network_name),
dbmfi_offsetof(tv_episode_sort),
dbmfi_offsetof(tv_season_num),
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
dbmfi_offsetof(songartistid),
Maintain songalbumid inside the files table songalbumid is used a lot in queries from Remote; computing the hash for each row is a major waste of time on big libraries and slow machines, so let's store the hash in the table. This brings us to schema version 7.
2010-03-06 11:13:56 -05:00
dbmfi_offsetof(songalbumid),
Add sort tags to the database
2010-09-21 07:16:38 -04:00
dbmfi_offsetof(title_sort),
dbmfi_offsetof(artist_sort),
dbmfi_offsetof(album_sort),
dbmfi_offsetof(album_artist_sort),
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
dbmfi_offsetof(composer_sort),
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
dbmfi_offsetof(channels),
Add new database code
2009-06-07 12:56:35 -04:00
};
/* This list must be kept in sync with
* - the order of the columns in the playlists table
* - the name of the fields in struct playlist_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const ssize_t dbpli_cols_map[] =
Add new database code
2009-06-07 12:56:35 -04:00
{
dbpli_offsetof(id),
dbpli_offsetof(title),
dbpli_offsetof(type),
dbpli_offsetof(query),
dbpli_offsetof(db_timestamp),
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
dbpli_offsetof(disabled),
Add new database code
2009-06-07 12:56:35 -04:00
dbpli_offsetof(path),
dbpli_offsetof(index),
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
dbpli_offsetof(special_id),
db: add missing field "virtual_path" in struct db_playlist_info (fixes segfault when loading playlists)
2015-02-23 14:49:53 -05:00
dbpli_offsetof(virtual_path),
Fixup parent playlist
2015-03-14 18:35:19 -04:00
dbpli_offsetof(parent_id),
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
dbpli_offsetof(directory_id),
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
dbpli_offsetof(query_order),
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
dbpli_offsetof(query_limit),
[db] Add missing declarations of media_kind column in commit 40c7522 (fixes issue #836)
2019-11-02 19:16:20 -04:00
dbpli_offsetof(media_kind),
Count playlist items on the fly
2009-06-11 12:28:01 -04:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
dbpli_offsetof(items),
dbpli_offsetof(streams),
Add new database code
2009-06-07 12:56:35 -04:00
};
Add database code for groups queries
2010-01-10 06:26:48 -05:00
/* This list must be kept in sync with
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
* - the order of fields in the Q_GROUP_ALBUMS and Q_GROUP_ARTISTS query
Add database code for groups queries
2010-01-10 06:26:48 -05:00
* - the name of the fields in struct group_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const ssize_t dbgri_cols_map[] =
Add database code for groups queries
2010-01-10 06:26:48 -05:00
{
Make album groups persistent Store groups (only album groups supported at the moment) in the DB, so their ids are persistent for the duration of the forked-daapd session. Those ids are used to, among other things, retrieve artwork, so we must provide ourselves some persistence here. This brings us to schema version 8.
2010-03-06 12:56:30 -05:00
dbgri_offsetof(id),
Add database code for groups queries
2010-01-10 06:26:48 -05:00
dbgri_offsetof(persistentid),
dbgri_offsetof(itemname),
Fix bug where sort fields were not implemented in group replies
2013-12-18 13:14:39 -05:00
dbgri_offsetof(itemname_sort),
Some cleaning up in group handling in db.c in prep for artist groups
2013-12-15 15:47:49 -05:00
dbgri_offsetof(itemcount),
dbgri_offsetof(groupalbumcount),
dbgri_offsetof(songalbumartist),
Support songartistid (asri) in group requests and queuefilter=artist - credit misenhower of wp8remote.com
2014-02-21 14:39:57 -05:00
dbgri_offsetof(songartistid),
[db] Add song_length to group info (fixes #265)
2016-06-11 17:10:13 -04:00
dbgri_offsetof(song_length),
Add database code for groups queries
2010-01-10 06:26:48 -05:00
};
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
/* This list must be kept in sync with
* - the order of the columns in the inotify table
* - the name and type of the fields in struct watch_info
*/
Constify data tables where possible
2010-03-23 13:55:39 -04:00
static const struct col_type_map wi_cols_map[] =
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
{ "wd", wi_offsetof(wd), DB_TYPE_INT, DB_FLAG_NO_BIND },
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{ "cookie", wi_offsetof(cookie), DB_TYPE_INT },
{ "path", wi_offsetof(path), DB_TYPE_STRING },
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
};
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
/* Sort clauses, used for ORDER BY */
/* Keep in sync with enum sort_type and indices */
Consolidate sort clauses
2010-08-05 12:24:50 -04:00
static const char *sort_clause[] =
{
"",
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
"f.title_sort",
"f.album_sort, f.disc, f.track",
"f.album_artist_sort, f.album_sort, f.disc, f.track",
"f.type, f.parent_id, f.special_id, f.title",
"f.year",
"f.genre",
"f.composer_sort",
"f.disc",
"f.track",
[db,jsonapi] case insensitive directory/file listing (#784) * [db,jsonapi] case insensitive directory/file listing * [jsonapi] file listing of playlist uses same VPATH ordering as per directory and files * [db,jsonapi] sorting via existing S_VPATH * [db] replace LOWER with COLLATE NOCASE
2019-08-21 16:54:34 -04:00
"f.virtual_path COLLATE NOCASE",
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
"pos",
"shuffle_pos",
};
/* Browse clauses, used for SELECT, WHERE, GROUP BY and for default ORDER BY
* Keep in sync with enum query_type and indices
* Col 1: for SELECT, Col 2: for WHERE, Col 3: for GROUP BY/ORDER BY
*/
static const struct browse_clause browse_clause[] =
{
{ "", "", "" },
{ "f.album_artist, f.album_artist_sort", "f.album_artist", "f.album_artist_sort, f.album_artist" },
{ "f.album, f.album_sort", "f.album", "f.album_sort, f.album" },
{ "f.genre, f.genre", "f.genre", "f.genre" },
{ "f.composer, f.composer_sort", "f.composer", "f.composer_sort, f.composer" },
{ "f.year, f.year", "f.year", "f.year" },
{ "f.disc, f.disc", "f.disc", "f.disc" },
{ "f.track, f.track", "f.track", "f.track" },
{ "f.virtual_path, f.virtual_path", "f.virtual_path", "f.virtual_path" },
{ "f.path, f.path", "f.path", "f.path" },
Consolidate sort clauses
2010-08-05 12:24:50 -04:00
};
[db] Add function to get a human readable string for data and media kind
2018-02-24 05:28:42 -05:00
struct media_kind_label {
enum media_kind type;
const char *label;
};
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
[db] Add function to get a human readable string for data and media kind
2018-02-24 05:28:42 -05:00
/* Keep in sync with enum media_kind */
static const struct media_kind_label media_kind_labels[] =
{
{ MEDIA_KIND_MUSIC, "music" },
{ MEDIA_KIND_MOVIE, "movie" },
{ MEDIA_KIND_PODCAST, "podcast" },
{ MEDIA_KIND_AUDIOBOOK, "audiobook" },
{ MEDIA_KIND_MUSICVIDEO, "musicvideo" },
{ MEDIA_KIND_TVSHOW, "tvshow" },
};
const char *
db_media_kind_label(enum media_kind media_kind)
{
int i;
for (i = 0; i < ARRAY_SIZE(media_kind_labels); i++)
{
if (media_kind == media_kind_labels[i].type)
return media_kind_labels[i].label;
}
return NULL;
}
enum media_kind
db_media_kind_enum(const char *label)
{
int i;
if (!label)
return 0;
for (i = 0; i < ARRAY_SIZE(media_kind_labels); i++)
{
if (strcmp(label, media_kind_labels[i].label) == 0)
return media_kind_labels[i].type;
}
return 0;
}
/* Keep in sync with enum data_kind */
static char *data_kind_label[] = { "file", "url", "spotify", "pipe" };
const char *
db_data_kind_label(enum data_kind data_kind)
{
if (data_kind < ARRAY_SIZE(data_kind_label))
{
return data_kind_label[data_kind];
}
return NULL;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/* Shuffle RNG state */
struct rng_ctx shuffle_rng;
Make database location a configuration item
2010-03-21 06:33:05 -04:00
static char *db_path;
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
static bool db_rating_updates;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
static __thread sqlite3 *hdl;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
static __thread struct db_statements db_statements;
Add new database code
2009-06-07 12:56:35 -04:00
Count playlist items on the fly
2009-06-11 12:28:01 -04:00
/* Forward */
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
static enum group_type
db_group_type_bypersistentid(int64_t persistentid);
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
static int
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(char *query, int free, short update_events);
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
Count playlist items on the fly
2009-06-11 12:28:01 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
char *
db_escape_string(const char *str)
{
char *escaped;
char *ret;
escaped = sqlite3_mprintf("%q", str);
if (!escaped)
{
DPRINTF(E_LOG, L_DB, "Out of memory for escaped string\n");
return NULL;
}
ret = strdup(escaped);
sqlite3_free(escaped);
return ret;
}
[db] Add methods db_mprintf() and db_snprintf() which wrap sqlite
2017-10-14 04:14:09 -04:00
// Basically a wrapper for sqlite3_mprintf()
char *
db_mprintf(const char *fmt, ...)
{
char *query;
char *ret;
va_list va;
va_start(va, fmt);
ret = sqlite3_vmprintf(fmt, va);
if (!ret)
{
DPRINTF(E_FATAL, L_MISC, "Out of memory for db_mprintf\n");
abort();
}
va_end(va);
query = strdup(ret);
sqlite3_free(ret);
return query;
}
int
db_snprintf(char *s, int n, const char *fmt, ...)
{
char *ret;
va_list va;
if (n < 2)
return -1;
[db] Faster size check in db.c's db_snprintf()
2017-10-14 07:17:21 -04:00
// For size check since sqlite3_vsnprintf does not seem to support it
s[n - 2] = '\0';
[db] Add methods db_mprintf() and db_snprintf() which wrap sqlite
2017-10-14 04:14:09 -04:00
va_start(va, fmt);
ret = sqlite3_vsnprintf(n, s, fmt, va);
va_end(va);
[db] Faster size check in db.c's db_snprintf()
2017-10-14 07:17:21 -04:00
if (!ret || (s[n - 2] != '\0'))
[db] Add methods db_mprintf() and db_snprintf() which wrap sqlite
2017-10-14 04:14:09 -04:00
return -1;
return 0;
}
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
void
free_pi(struct pairing_info *pi, int content_only)
{
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
if (!pi)
return;
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
free(pi->remote_id);
free(pi->name);
free(pi->guid);
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
if (!content_only)
free(pi);
Fix bug in m3u scanner
2014-04-18 07:08:31 -04:00
else
memset(pi, 0, sizeof(struct pairing_info));
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
}
Add new database code
2009-06-07 12:56:35 -04:00
void
free_mfi(struct media_file_info *mfi, int content_only)
{
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
if (!mfi)
return;
Add sort tags to the database
2010-09-21 07:16:38 -04:00
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
free(mfi->path);
free(mfi->fname);
free(mfi->title);
free(mfi->artist);
free(mfi->album);
free(mfi->genre);
free(mfi->comment);
free(mfi->type);
free(mfi->composer);
free(mfi->orchestra);
free(mfi->conductor);
free(mfi->grouping);
free(mfi->description);
free(mfi->codectype);
free(mfi->album_artist);
free(mfi->tv_series_name);
free(mfi->tv_episode_num_str);
free(mfi->tv_network_name);
free(mfi->title_sort);
free(mfi->artist_sort);
free(mfi->album_sort);
free(mfi->composer_sort);
free(mfi->album_artist_sort);
free(mfi->virtual_path);
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
Add new database code
2009-06-07 12:56:35 -04:00
if (!content_only)
free(mfi);
Fix bug in m3u scanner
2014-04-18 07:08:31 -04:00
else
memset(mfi, 0, sizeof(struct media_file_info));
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
void
free_pli(struct playlist_info *pli, int content_only)
{
if (!pli)
return;
free(pli->title);
free(pli->query);
free(pli->path);
free(pli->virtual_path);
[db] Free order by-clause in playist_info
2018-04-15 03:33:41 -04:00
free(pli->query_order);
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
if (!content_only)
free(pli);
else
memset(pli, 0, sizeof(struct playlist_info));
}
void
free_di(struct directory_info *di, int content_only)
{
if (!di)
return;
free(di->virtual_path);
if (!content_only)
free(di);
else
memset(di, 0, sizeof(struct directory_info));
}
void
free_query_params(struct query_params *qp, int content_only)
{
if (!qp)
return;
free(qp->filter);
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
free(qp->having);
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
free(qp->order);
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
if (!content_only)
free(qp);
else
memset(qp, 0, sizeof(struct query_params));
}
void
free_queue_item(struct db_queue_item *queue_item, int content_only)
{
if (!queue_item)
return;
free(queue_item->path);
free(queue_item->virtual_path);
free(queue_item->title);
free(queue_item->artist);
free(queue_item->album_artist);
[db] schema v19.11 support composer in queue tbl
2018-11-21 07:52:13 -05:00
free(queue_item->composer);
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
free(queue_item->album);
free(queue_item->genre);
free(queue_item->artist_sort);
free(queue_item->album_sort);
free(queue_item->album_artist_sort);
free(queue_item->artwork_url);
[db] schema v20.01 support codec type/bitrate/samplerate in queue tbl
2019-06-04 16:51:44 -04:00
free(queue_item->type);
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
if (!content_only)
free(queue_item);
else
memset(queue_item, 0, sizeof(struct db_queue_item));
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
static void
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
sort_tag_create(char **sort_tag, const char *src_tag)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
const uint8_t *i_ptr;
const uint8_t *n_ptr;
const uint8_t *number;
uint8_t out[1024];
uint8_t *o_ptr;
int append_number;
ucs4_t puc;
int numlen;
size_t len;
int charlen;
/* Note: include terminating NUL in string length for u8_normalize */
if (*sort_tag)
{
[db] Move calculation of artist/album id's from sqlite to code The purpose of this is to support library backends making their own calculation of these id's, which is relevant if they have more information available than just album_artist and album. This also removes a bunch of sqlite extension code plus some triggers, which in itself is probably an improvement.
2019-05-12 17:28:38 -04:00
DPRINTF(E_DBG, L_DB, "Existing sort tag will be normalized: %s\n", *sort_tag);
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
o_ptr = u8_normalize(UNINORM_NFD, (uint8_t *)*sort_tag, strlen(*sort_tag) + 1, NULL, &len);
free(*sort_tag);
*sort_tag = (char *)o_ptr;
return;
}
if (!src_tag || ((len = strlen(src_tag)) == 0))
{
*sort_tag = NULL;
return;
}
// Set input pointer past article if present
if ((strncasecmp(src_tag, "a ", 2) == 0) && (len > 2))
i_ptr = (uint8_t *)(src_tag + 2);
else if ((strncasecmp(src_tag, "an ", 3) == 0) && (len > 3))
i_ptr = (uint8_t *)(src_tag + 3);
else if ((strncasecmp(src_tag, "the ", 4) == 0) && (len > 4))
i_ptr = (uint8_t *)(src_tag + 4);
else
i_ptr = (uint8_t *)src_tag;
// Poor man's natural sort. Makes sure we sort like this: a1, a2, a10, a11, a21, a111
// We do this by padding zeroes to (short) numbers. As an alternative we could have
// made a proper natural sort algorithm in sqlext.c, but we don't, since we don't
// want any risk of hurting response times
memset(&out, 0, sizeof(out));
o_ptr = (uint8_t *)&out;
number = NULL;
append_number = 0;
do
{
n_ptr = u8_next(&puc, i_ptr);
if (uc_is_digit(puc))
{
if (!number) // We have encountered the beginning of a number
number = i_ptr;
append_number = (n_ptr == NULL); // If last char in string append number now
}
else
{
if (number)
append_number = 1; // A number has ended so time to append it
else
{
charlen = u8_strmblen(i_ptr);
if (charlen >= 0)
o_ptr = u8_stpncpy(o_ptr, i_ptr, charlen); // No numbers in sight, just append char
}
}
// Break if less than 100 bytes remain (prevent buffer overflow)
if (sizeof(out) - u8_strlen(out) < 100)
break;
// Break if number is very large (prevent buffer overflow)
if (number && (i_ptr - number > 50))
break;
if (append_number)
{
numlen = i_ptr - number;
if (numlen < 5) // Max pad width
{
u8_strcpy(o_ptr, (uint8_t *)"00000");
o_ptr += (5 - numlen);
}
o_ptr = u8_stpncpy(o_ptr, number, numlen + u8_strmblen(i_ptr));
number = NULL;
append_number = 0;
}
i_ptr = n_ptr;
}
while (n_ptr);
*sort_tag = (char *)u8_normalize(UNINORM_NFD, (uint8_t *)&out, u8_strlen(out) + 1, NULL, &len);
}
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
static void
fixup_sanitize(char **tag, enum fixup_type fixup, struct fixup_ctx *ctx)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
char *ret;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
if (!tag || !*tag)
return;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
switch (fixup)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_NO_SANITIZE:
case DB_FIXUP_CODECTYPE:
break; // Don't touch the above
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
default:
trim(*tag);
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
// By default we set empty strings to NULL
if (*tag[0] == '\0')
{
free(*tag);
*tag = NULL;
break;
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
ret = unicode_fixup_string(*tag, "ascii");
if (ret != *tag)
{
free(*tag);
*tag = ret;
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
}
static void
fixup_defaults(char **tag, enum fixup_type fixup, struct fixup_ctx *ctx)
{
char *ca;
switch(fixup)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Move calculation of artist/album id's from sqlite to code The purpose of this is to support library backends making their own calculation of these id's, which is relevant if they have more information available than just album_artist and album. This also removes a bunch of sqlite extension code plus some triggers, which in itself is probably an improvement.
2019-05-12 17:28:38 -04:00
case DB_FIXUP_SONGARTISTID:
if (ctx->mfi && ctx->mfi->songartistid == 0)
ctx->mfi->songartistid = two_str_hash(ctx->mfi->album_artist, NULL);
break;
case DB_FIXUP_SONGALBUMID:
if (ctx->mfi && ctx->mfi->songalbumid == 0)
ctx->mfi->songalbumid = two_str_hash(ctx->mfi->album_artist, ctx->mfi->album);
break;
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_TITLE:
if (*tag)
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
// fname is left untouched by fixup_sanitize() for obvious reasons, so ensure it is proper UTF-8
if (ctx->mfi && ctx->mfi->fname)
{
*tag = unicode_fixup_string(ctx->mfi->fname, "ascii");
if (*tag == ctx->mfi->fname)
*tag = strdup(ctx->mfi->fname);
}
else if (ctx->pli && ctx->pli->path)
*tag = strdup(ctx->pli->path);
else if (ctx->queue_item && ctx->queue_item->path)
*tag = strdup(ctx->queue_item->path);
else
*tag = strdup("Unknown title");
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ARTIST:
if (*tag)
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Use album_artist if we have no artist metadata
2018-12-29 19:11:11 -05:00
if (ctx->mfi && ctx->mfi->album_artist)
*tag = strdup(ctx->mfi->album_artist);
else if (ctx->mfi && ctx->mfi->orchestra && ctx->mfi->conductor)
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
*tag = safe_asprintf("%s - %s", ctx->mfi->orchestra, ctx->mfi->conductor);
else if (ctx->mfi && ctx->mfi->orchestra)
*tag = strdup(ctx->mfi->orchestra);
else if (ctx->mfi && ctx->mfi->conductor)
*tag = strdup(ctx->mfi->conductor);
else if (ctx->mfi && ctx->mfi->tv_series_name)
*tag = strdup(ctx->mfi->tv_series_name);
else
*tag = strdup("Unknown artist");
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ALBUM:
if (*tag)
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
if (ctx->mfi && ctx->mfi->tv_series_name)
*tag = safe_asprintf("%s, Season %u", ctx->mfi->tv_series_name, ctx->mfi->tv_season_num);
else
*tag = strdup("Unknown album");
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ALBUM_ARTIST: // Will be set after artist, because artist (must) come first in the col_maps
if (ctx->mfi && ctx->mfi->media_kind == MEDIA_KIND_PODCAST)
{
free(*tag);
*tag = strdup("");
}
if (*tag)
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Change use of compilation_artist, so that album_artist has preference This change means that we will use album_artist even if compilation_artist is configured, thus compilation_artist will only be used to override artist.
2018-12-30 04:54:05 -05:00
if (ctx->mfi && ctx->mfi->compilation && (ca = cfg_getstr(cfg_getsec(cfg, "library"), "compilation_artist")))
*tag = strdup(ca); // If ca is empty string then the artist will not be shown in artist view
else if (ctx->mfi && ctx->mfi->artist)
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
*tag = strdup(ctx->mfi->artist);
else if (ctx->queue_item && ctx->queue_item->artist)
*tag = strdup(ctx->queue_item->artist);
else
[db] Change use of compilation_artist, so that album_artist has preference This change means that we will use album_artist even if compilation_artist is configured, thus compilation_artist will only be used to override artist.
2018-12-30 04:54:05 -05:00
*tag = strdup("Unknown artist");
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_GENRE:
if (*tag)
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
*tag = strdup("Unknown genre");
break;
case DB_FIXUP_MEDIA_KIND:
if (ctx->mfi && ctx->mfi->tv_series_name)
ctx->mfi->media_kind = MEDIA_KIND_TVSHOW;
[db] Transfer some library tag fixup to the db's generic fixup Transfer setting defaults for media_kind and item_kind. Also sets default media_kind for queue_items.
2018-12-30 10:13:57 -05:00
else if (ctx->mfi && !ctx->mfi->media_kind)
ctx->mfi->media_kind = MEDIA_KIND_MUSIC;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
else if (ctx->pli && !ctx->pli->media_kind)
ctx->pli->media_kind = MEDIA_KIND_MUSIC;
[db] Transfer some library tag fixup to the db's generic fixup Transfer setting defaults for media_kind and item_kind. Also sets default media_kind for queue_items.
2018-12-30 10:13:57 -05:00
else if (ctx->queue_item && !ctx->queue_item->media_kind)
ctx->queue_item->media_kind = MEDIA_KIND_MUSIC;
break;
case DB_FIXUP_ITEM_KIND:
if (ctx->mfi && !ctx->mfi->item_kind)
ctx->mfi->item_kind = 2; // music
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
break;
case DB_FIXUP_TIME_MODIFIED:
if (ctx->mfi && ctx->mfi->time_modified == 0)
ctx->mfi->time_modified = ctx->mfi->db_timestamp;
break;
case DB_FIXUP_CODECTYPE:
case DB_FIXUP_TYPE:
// Default to mpeg4 video/audio for unknown file types in an attempt to allow streaming of DRM-afflicted files
if (ctx->mfi && ctx->mfi->codectype && strcmp(ctx->mfi->codectype, "unkn") == 0)
{
if (ctx->mfi->has_video)
{
strcpy(ctx->mfi->codectype, "mp4v");
strcpy(ctx->mfi->type, "m4v");
}
else
{
strcpy(ctx->mfi->codectype, "mp4a");
strcpy(ctx->mfi->type, "m4a");
}
}
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
default:
break;
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
static void
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
fixup_sort_tags(char **tag, enum fixup_type fixup, struct fixup_ctx *ctx)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
switch(fixup)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_TITLE_SORT:
if (ctx->mfi)
sort_tag_create(tag, ctx->mfi->title);
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ARTIST_SORT:
if (ctx->mfi)
sort_tag_create(tag, ctx->mfi->artist);
else if (ctx->queue_item)
sort_tag_create(tag, ctx->queue_item->artist);
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ALBUM_SORT:
if (ctx->mfi)
sort_tag_create(tag, ctx->mfi->album);
else if (ctx->queue_item)
sort_tag_create(tag, ctx->queue_item->album);
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_ALBUM_ARTIST_SORT:
if (ctx->mfi)
sort_tag_create(tag, ctx->mfi->album_artist);
else if (ctx->queue_item)
sort_tag_create(tag, ctx->queue_item->album_artist);
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
case DB_FIXUP_COMPOSER_SORT:
if (ctx->mfi)
sort_tag_create(tag, ctx->mfi->composer);
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
default:
break;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
}
static void
fixup_tags(struct fixup_ctx *ctx)
{
void (*fixup_func[])(char **, enum fixup_type, struct fixup_ctx *) = { fixup_sanitize, fixup_defaults, fixup_sort_tags };
char **tag;
int i;
int j;
for (i = 0; i < ARRAY_SIZE(fixup_func); i++)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
for (j = 0; j < ctx->map_size; j++)
{
switch (ctx->map[j].type)
{
case DB_TYPE_STRING:
tag = (char **) ((char *)ctx->data + ctx->map[j].offset);
fixup_func[i](tag, ctx->map[j].fixup, ctx);
break;
case DB_TYPE_INT:
case DB_TYPE_INT64:
fixup_func[i](NULL, ctx->map[j].fixup, ctx);
break;
}
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
static void
fixup_tags_mfi(struct media_file_info *mfi)
{
struct fixup_ctx ctx = { 0 };
ctx.data = mfi;
ctx.mfi = mfi;
ctx.map = mfi_cols_map;
ctx.map_size = ARRAY_SIZE(mfi_cols_map);
fixup_tags(&ctx);
}
static void
fixup_tags_pli(struct playlist_info *pli)
{
struct fixup_ctx ctx = { 0 };
ctx.data = pli;
ctx.pli = pli;
ctx.map = pli_cols_map;
ctx.map_size = ARRAY_SIZE(pli_cols_map);
fixup_tags(&ctx);
}
static void
fixup_tags_queue_item(struct db_queue_item *queue_item)
{
struct fixup_ctx ctx = { 0 };
ctx.data = queue_item;
ctx.queue_item = queue_item;
ctx.map = qi_cols_map;
ctx.map_size = ARRAY_SIZE(qi_cols_map);
fixup_tags(&ctx);
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
static int
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
bind_generic(sqlite3_stmt *stmt, void *data, const struct col_type_map *map, size_t map_size, int id)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
char **strptr;
char *ptr;
int i;
int n;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
for (i = 0, n = 1; i < map_size; i++)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (map[i].flag & DB_FLAG_NO_BIND)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
continue;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ptr = data + map[i].offset;
strptr = (char **)(data + map[i].offset);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
switch (map[i].type)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
case DB_TYPE_INT:
[db] Fix integer overflow in bind_mfi (ref issue #683) Also drop DB_TYPE_CHAR since it's not really being used.
2019-01-30 17:34:00 -05:00
sqlite3_bind_int64(stmt, n, *((uint32_t *)ptr)); // Use _int64 because _int is for signed int32
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
break;
case DB_TYPE_INT64:
sqlite3_bind_int64(stmt, n, *((uint64_t *)ptr));
break;
case DB_TYPE_STRING:
sqlite3_bind_text(stmt, n, *strptr, -1, SQLITE_STATIC); // TODO should we use _TRANSIENT?
break;
default:
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
DPRINTF(E_LOG, L_DB, "BUG: Unknown type %d in column map\n", map[i].type);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
return -1;
}
n++;
}
// This binds the final "WHERE id = ?" if it is an update
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (id)
sqlite3_bind_int(stmt, n, id);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
return 0;
}
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
static int
bind_mfi(sqlite3_stmt *stmt, struct media_file_info *mfi)
{
return bind_generic(stmt, mfi, mfi_cols_map, ARRAY_SIZE(mfi_cols_map), mfi->id);
}
static int
bind_pli(sqlite3_stmt *stmt, struct playlist_info *pli)
{
return bind_generic(stmt, pli, pli_cols_map, ARRAY_SIZE(pli_cols_map), pli->id);
}
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
/* Unlock notification support */
static void
unlock_notify_cb(void **args, int nargs)
{
struct db_unlock *u;
int i;
for (i = 0; i < nargs; i++)
{
u = (struct db_unlock *)args[i];
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_mutex_lock(&u->lck));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
u->proceed = 1;
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_cond_signal(&u->cond));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_mutex_unlock(&u->lck));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
}
}
static int
db_wait_unlock(void)
{
struct db_unlock u;
int ret;
u.proceed = 0;
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, mutex_init(&u.lck));
CHECK_ERR(L_DB, pthread_cond_init(&u.cond, NULL));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = sqlite3_unlock_notify(hdl, unlock_notify_cb, &u);
if (ret == SQLITE_OK)
{
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_mutex_lock(&u.lck));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
if (!u.proceed)
Extra log message for debugging apparent db locking issue
2014-05-13 16:02:32 -04:00
{
DPRINTF(E_INFO, L_DB, "Waiting for database unlock\n");
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_cond_wait(&u.cond, &u.lck));
Extra log message for debugging apparent db locking issue
2014-05-13 16:02:32 -04:00
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_mutex_unlock(&u.lck));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
}
[threads] Update mutex/cond functions to use new CHECK_ERR macros Added various macros to check return values and log any errors and abort if the call fails. Updated logging to handle early errors before logging initialized.
2017-01-21 10:11:20 -05:00
CHECK_ERR(L_DB, pthread_cond_destroy(&u.cond));
CHECK_ERR(L_DB, pthread_mutex_destroy(&u.lck));
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
return ret;
}
static int
db_blocking_step(sqlite3_stmt *stmt)
{
int ret;
while ((ret = sqlite3_step(stmt)) == SQLITE_LOCKED)
{
ret = db_wait_unlock();
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Database deadlocked!\n");
break;
}
sqlite3_reset(stmt);
}
return ret;
}
static int
db_blocking_prepare_v2(const char *query, int len, sqlite3_stmt **stmt, const char **end)
{
int ret;
while ((ret = sqlite3_prepare_v2(hdl, query, len, stmt, end)) == SQLITE_LOCKED)
{
ret = db_wait_unlock();
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Database deadlocked!\n");
break;
}
}
return ret;
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
static int
db_statement_run(sqlite3_stmt *stmt)
{
int ret;
#ifdef HAVE_SQLITE3_EXPANDED_SQL
char *query;
if (logger_severity() >= E_DBG)
{
query = sqlite3_expanded_sql(stmt);
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
sqlite3_free(query);
}
#else
DPRINTF(E_DBG, L_DB, "Running query (prepared statement)\n");
#endif
while ((ret = db_blocking_step(stmt)) == SQLITE_ROW)
; /* EMPTY */
if (ret != SQLITE_DONE)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
}
sqlite3_reset(stmt);
sqlite3_clear_bindings(stmt);
return (ret == SQLITE_DONE) ? sqlite3_changes(hdl) : -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
/* Modelled after sqlite3_exec() */
static int
db_exec(const char *query, char **errmsg)
{
sqlite3_stmt *stmt;
Handle SQLITE_SCHEMA error in db_exec() This happens under database load with many concurrent threads doing updates; queries failing with SQLITE_SCHEMA at step time need to retried from scratch until they succeeded or hit a best-effort limit of 5 retries.
2011-05-28 04:48:31 -04:00
int try;
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
int ret;
*errmsg = NULL;
Handle SQLITE_SCHEMA error in db_exec() This happens under database load with many concurrent threads doing updates; queries failing with SQLITE_SCHEMA at step time need to retried from scratch until they succeeded or hit a best-effort limit of 5 retries.
2011-05-28 04:48:31 -04:00
for (try = 0; try < 5; try++)
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
{
Handle SQLITE_SCHEMA error in db_exec() This happens under database load with many concurrent threads doing updates; queries failing with SQLITE_SCHEMA at step time need to retried from scratch until they succeeded or hit a best-effort limit of 5 retries.
2011-05-28 04:48:31 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
*errmsg = sqlite3_mprintf("prepare failed: %s", sqlite3_errmsg(hdl));
return ret;
}
while ((ret = db_blocking_step(stmt)) == SQLITE_ROW)
; /* EMPTY */
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
Handle SQLITE_SCHEMA error in db_exec() This happens under database load with many concurrent threads doing updates; queries failing with SQLITE_SCHEMA at step time need to retried from scratch until they succeeded or hit a best-effort limit of 5 retries.
2011-05-28 04:48:31 -04:00
sqlite3_finalize(stmt);
if (ret != SQLITE_SCHEMA)
break;
}
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
if (ret != SQLITE_DONE)
{
Enhance db_exec() error messages
2011-05-28 04:46:41 -04:00
*errmsg = sqlite3_mprintf("step failed: %s", sqlite3_errmsg(hdl));
Introduce db_exec(), replacing sqlite3_exec()
2010-04-26 12:24:09 -04:00
return ret;
}
return SQLITE_OK;
}
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
/* Maintenance and DB hygiene */
static void
[db/library] Use "PRAGMA optimize" instead of "ANALYZE" ANALYZE collects and saves statistics even if there were no database changes and the last collected data is still good. According to the sqlite3 documentation, it is recommended to use "PRAGMA optimize" which will call "ANALYZE" if it is necessary. "PRAGMA optimize" will run "ANALYZE" based on prior queries on the same database connection. It is recommended to run optimize before closing the connection. (see https://www.sqlite.org/lang_analyze.html)
2018-02-23 13:44:40 -05:00
db_pragma_optimize(void)
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
{
[db] Use ANALYZE instead of PRAGMA optimize (reverts commit cd96ec5) Turns out PRAGMA optimize does not analyze tables on a fresh install, which means that sqlite_stat1 is not available for the query planner, which means that wrong indexes are used. See https://www.raspberrypi.org/forums/viewtopic.php?f=66&t=49928&sid=1e5d1d418315d7565ae027d751dd94a0&start=1350#p1328964
2018-06-16 15:43:58 -04:00
const char *query = "ANALYZE;";
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
char *errmsg;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
[db] Use ANALYZE instead of PRAGMA optimize (reverts commit cd96ec5) Turns out PRAGMA optimize does not analyze tables on a fresh install, which means that sqlite_stat1 is not available for the query planner, which means that wrong indexes are used. See https://www.raspberrypi.org/forums/viewtopic.php?f=66&t=49928&sid=1e5d1d418315d7565ae027d751dd94a0&start=1350#p1328964
2018-06-16 15:43:58 -04:00
DPRINTF(E_LOG, L_DB, "ANALYZE failed: %s\n", errmsg);
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
sqlite3_free(errmsg);
}
}
Configurable library names Names of Library, Music, Movies, TV Shows and Podcasts made configurable
2013-11-30 06:57:38 -05:00
/* Set names of default playlists according to config */
static void
db_set_cfg_names(void)
{
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
#define Q_TMPL "UPDATE playlists SET title = '%q' WHERE type = %d AND special_id = %d;"
Basic audiobook support
2013-12-08 17:03:03 -05:00
char *cfg_item[6] = { "name_library", "name_music", "name_movies", "name_tvshows", "name_podcasts", "name_audiobooks" };
char special_id[6] = { 0, 6, 4, 5, 1, 7 };
Configurable library names Names of Library, Music, Movies, TV Shows and Podcasts made configurable
2013-11-30 06:57:38 -05:00
cfg_t *lib;
char *query;
char *title;
char *errmsg;
int ret;
int i;
lib = cfg_getsec(cfg, "library");
for (i = 0; i < (sizeof(cfg_item) / sizeof(cfg_item[0])); i++)
{
title = cfg_getstr(lib, cfg_item[i]);
if (!title)
{
DPRINTF(E_LOG, L_DB, "Internal error, unknown config item '%s'\n", cfg_item[i]);
continue;
}
[smartpl] refactoring: repurpose playlist type PL_SMART for user created smart playlists and introduce new type PL_SPECIAL for special system playlists
2015-04-11 10:55:13 -04:00
query = sqlite3_mprintf(Q_TMPL, title, PL_SPECIAL, special_id[i]);
Configurable library names Names of Library, Music, Movies, TV Shows and Podcasts made configurable
2013-11-30 06:57:38 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Error setting playlist title, query %s, error: %s\n", query, errmsg);
sqlite3_free(errmsg);
}
else
DPRINTF(E_DBG, L_DB, "Playlist title for config item '%s' set with query '%s'\n", cfg_item[i], query);
sqlite3_free(query);
}
#undef Q_TMPL
}
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
void
db_hook_post_scan(void)
{
DPRINTF(E_DBG, L_DB, "Running post-scan DB maintenance tasks...\n");
[db/library] Use "PRAGMA optimize" instead of "ANALYZE" ANALYZE collects and saves statistics even if there were no database changes and the last collected data is still good. According to the sqlite3 documentation, it is recommended to use "PRAGMA optimize" which will call "ANALYZE" if it is necessary. "PRAGMA optimize" will run "ANALYZE" based on prior queries on the same database connection. It is recommended to run optimize before closing the connection. (see https://www.sqlite.org/lang_analyze.html)
2018-02-23 13:44:40 -05:00
db_pragma_optimize();
Add DB maintenance routines
2010-12-05 06:22:52 -05:00
DPRINTF(E_DBG, L_DB, "Done with post-scan DB maintenance\n");
}
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
void
db_purge_cruft(time_t ref)
{
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
#define Q_TMPL "DELETE FROM directories WHERE id >= %d AND db_timestamp < %" PRIi64 ";"
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
int i;
int ret;
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
char *query;
[db/filescanner] Add index on fname, change playlist matching (wip)
2017-10-14 03:12:52 -04:00
char *queries_tmpl[4] =
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
{
[db/filescanner] Add index on fname, change playlist matching (wip)
2017-10-14 03:12:52 -04:00
"DELETE FROM playlistitems WHERE playlistid IN (SELECT p.id FROM playlists p WHERE p.type <> %d AND p.db_timestamp < %" PRIi64 ");",
"DELETE FROM playlistitems WHERE filepath IN (SELECT f.path FROM files f WHERE -1 <> %d AND f.db_timestamp < %" PRIi64 ");",
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
"DELETE FROM playlists WHERE type <> %d AND db_timestamp < %" PRIi64 ";",
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
"DELETE FROM files WHERE -1 <> %d AND db_timestamp < %" PRIi64 ";",
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
};
[db] wrap db_purge_cruft in a transaction
2016-12-27 15:31:01 -05:00
db_transaction_begin();
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
for (i = 0; i < (sizeof(queries_tmpl) / sizeof(queries_tmpl[0])); i++)
{
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
query = sqlite3_mprintf(queries_tmpl[i], PL_SPECIAL, (int64_t)ref);
if (!query)
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
[db] wrap db_purge_cruft in a transaction
2016-12-27 15:31:01 -05:00
db_transaction_end();
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
return;
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
}
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
DPRINTF(E_DBG, L_DB, "Running purge query '%s'\n", query);
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
}
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
query = sqlite3_mprintf(Q_TMPL, DIR_MAX, (int64_t)ref);
if (!query)
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
{
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
[db] wrap db_purge_cruft in a transaction
2016-12-27 15:31:01 -05:00
db_transaction_end();
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
return;
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
}
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
DPRINTF(E_DBG, L_DB, "Running purge query '%s'\n", query);
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
if (ret == 0)
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
[db] wrap db_purge_cruft in a transaction
2016-12-27 15:31:01 -05:00
db_transaction_end();
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
#undef Q_TMPL
Purge old files and playlists after bulk scan
2009-06-07 14:49:13 -04:00
}
Allow user to trigger full rescan with a .force-rescan file
2013-11-29 16:48:53 -05:00
void
db_purge_all(void)
{
[db] Add missing purge of directories in db_purge_all
2017-01-06 04:45:25 -05:00
#define Q_TMPL_PL "DELETE FROM playlists WHERE type <> %d;"
#define Q_TMPL_DIR "DELETE FROM directories WHERE id >= %d;"
Fix stupid oversight that can cause segfault - how typical to discover this right after making a release
2015-05-05 14:51:59 -04:00
char *queries[4] =
Allow user to trigger full rescan with a .force-rescan file
2013-11-29 16:48:53 -05:00
{
"DELETE FROM inotify;",
"DELETE FROM playlistitems;",
Include groups table in database purge
2013-12-16 16:21:04 -05:00
"DELETE FROM files;",
"DELETE FROM groups;",
Allow user to trigger full rescan with a .force-rescan file
2013-11-29 16:48:53 -05:00
};
char *errmsg;
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
char *query;
Allow user to trigger full rescan with a .force-rescan file
2013-11-29 16:48:53 -05:00
int i;
int ret;
for (i = 0; i < (sizeof(queries) / sizeof(queries[0])); i++)
{
DPRINTF(E_DBG, L_DB, "Running purge query '%s'\n", queries[i]);
ret = db_exec(queries[i], &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Purge query %d error: %s\n", i, errmsg);
sqlite3_free(errmsg);
}
else
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
}
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
[db] Add missing purge of directories in db_purge_all
2017-01-06 04:45:25 -05:00
// Purge playlists
query = sqlite3_mprintf(Q_TMPL_PL, PL_SPECIAL);
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
DPRINTF(E_DBG, L_DB, "Running purge query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Purge query '%s' error: %s\n", query, errmsg);
sqlite3_free(errmsg);
}
else
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
sqlite3_free(query);
[db] Add missing purge of directories in db_purge_all
2017-01-06 04:45:25 -05:00
// Purge directories
query = sqlite3_mprintf(Q_TMPL_DIR, DIR_MAX);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
DPRINTF(E_DBG, L_DB, "Running purge query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Purge query '%s' error: %s\n", query, errmsg);
sqlite3_free(errmsg);
}
else
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
sqlite3_free(query);
#undef Q_TMPL_PL
#undef Q_TMPL_DIR
Allow user to trigger full rescan with a .force-rescan file
2013-11-29 16:48:53 -05:00
}
Add new database code
2009-06-07 12:56:35 -04:00
static int
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
db_get_one_int(const char *query)
Add new database code
2009-06-07 12:56:35 -04:00
{
sqlite3_stmt *stmt;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_ROW)
{
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
if (ret == SQLITE_DONE)
DPRINTF(E_INFO, L_DB, "No matching row found for query: %s\n", query);
else
DPRINTF(E_LOG, L_DB, "Could not step: %s (%s)\n", sqlite3_errmsg(hdl), query);
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
return -1;
}
ret = sqlite3_column_int(stmt, 0);
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
return ret;
}
Rename db_query_get_count() to db_get_count() Make that a generic helper, given it's used outside queries.
2009-06-11 09:45:49 -04:00
Wrap bulk scan in a db transaction (credit @chme)
2014-05-11 17:13:09 -04:00
/* Transactions */
void
db_transaction_begin(void)
{
char *query = "BEGIN TRANSACTION;";
char *errmsg;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "SQL error running '%s': %s\n", query, errmsg);
sqlite3_free(errmsg);
}
}
void
db_transaction_end(void)
{
char *query = "END TRANSACTION;";
char *errmsg;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "SQL error running '%s': %s\n", query, errmsg);
sqlite3_free(errmsg);
}
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
void
db_transaction_rollback(void)
{
char *query = "ROLLBACK TRANSACTION;";
char *errmsg;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "SQL error running '%s': %s\n", query, errmsg);
sqlite3_free(errmsg);
}
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static void
db_free_query_clause(struct query_clause *qc)
{
if (!qc)
return;
Wrap bulk scan in a db transaction (credit @chme)
2014-05-11 17:13:09 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
sqlite3_free(qc->where);
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
sqlite3_free(qc->group);
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
sqlite3_free(qc->having);
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
sqlite3_free(qc->order);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
sqlite3_free(qc->index);
free(qc);
}
static struct query_clause *
db_build_query_clause(struct query_params *qp)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
struct query_clause *qc;
qc = calloc(1, sizeof(struct query_clause));
if (!qc)
goto error;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
if (qp->type & Q_F_BROWSE)
qc->group = sqlite3_mprintf("GROUP BY %s", browse_clause[qp->type & ~Q_F_BROWSE].group);
[db] Add "group" attribute to query_params and allow grouping files
2018-09-22 03:32:05 -04:00
else if (qp->group)
qc->group = sqlite3_mprintf("GROUP BY %s", qp->group);
else
qc->group = sqlite3_mprintf("");
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
if (qp->filter)
qc->where = sqlite3_mprintf("WHERE f.disabled = 0 AND %s", qp->filter);
else
qc->where = sqlite3_mprintf("WHERE f.disabled = 0");
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
if (qp->having && (qp->type & (Q_GROUP_ALBUMS | Q_GROUP_ARTISTS)))
[db] Add "group" attribute to query_params and allow grouping files
2018-09-22 03:32:05 -04:00
qc->having = sqlite3_mprintf("HAVING %s", qp->having);
else
qc->having = sqlite3_mprintf("");
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
if (qp->order)
qc->order = sqlite3_mprintf("ORDER BY %s", qp->order);
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
else if (qp->sort)
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
qc->order = sqlite3_mprintf("ORDER BY %s", sort_clause[qp->sort]);
else if (qp->type & Q_F_BROWSE)
qc->order = sqlite3_mprintf("ORDER BY %s", browse_clause[qp->type & ~Q_F_BROWSE].group);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
else
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
qc->order = sqlite3_mprintf("");
Let db_build_query_index_clause() always return an initialized idx, even on failure
2015-09-29 16:51:23 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
switch (qp->idx_type)
{
case I_FIRST:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
qc->index = sqlite3_mprintf("LIMIT %d", qp->limit);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case I_LAST:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
qc->index = sqlite3_mprintf("LIMIT -1 OFFSET %d", qp->results - qp->limit);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case I_SUB:
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
if (qp->limit)
qc->index = sqlite3_mprintf("LIMIT %d OFFSET %d", qp->limit, qp->offset);
else
qc->index = sqlite3_mprintf("LIMIT -1 OFFSET %d", qp->offset);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case I_NONE:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
qc->index = sqlite3_mprintf("");
break;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
if (!qc->where || !qc->index)
goto error;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return qc;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
error:
DPRINTF(E_LOG, L_DB, "Error building query clause\n");
db_free_query_clause(qc);
return NULL;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
db_build_query_check(struct query_params *qp, char *count, char *query)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
if (!count || !query)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
goto failed;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Rename db_get_count to db_get_one_int
2016-12-09 10:20:03 -05:00
qp->results = db_get_one_int(count);
Add new database code
2009-06-07 12:56:35 -04:00
if (qp->results < 0)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
DPRINTF(E_LOG, L_DB, "No results for count\n");
goto failed;
}
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
sqlite3_free(count);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return query;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
failed:
sqlite3_free(count);
sqlite3_free(query);
return NULL;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_items(struct query_params *qp, struct query_clause *qc)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *count;
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f %s;", qc->where);
[db] Add "group" attribute to query_params and allow grouping files
2018-09-22 03:32:05 -04:00
query = sqlite3_mprintf("SELECT f.* FROM files f %s %s %s %s;", qc->where, qc->group, qc->order, qc->index);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_pls(struct query_params *qp, struct query_clause *qc)
Add new database code
2009-06-07 12:56:35 -04:00
{
char *count;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *query;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM playlists f %s;", qc->where);
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = sqlite3_mprintf(Q_PL_SELECT " %s GROUP BY f.id %s %s;", qc->where, qc->order, qc->index);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add new database code
2009-06-07 12:56:35 -04:00
}
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_find_pls(struct query_params *qp, struct query_clause *qc)
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
{
if (!qp->filter)
{
DPRINTF(E_LOG, L_DB, "Bug! Playlist find called without search criteria\n");
return NULL;
}
// Use qp->filter because qc->where has a f.disabled which is not a column in playlistitems
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
sqlite3_free(qc->where);
qc->where = sqlite3_mprintf("WHERE f.id IN (SELECT playlistid FROM playlistitems WHERE %s)", qp->filter);
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
return db_build_query_pls(qp, qc);
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_plitems_plain(struct query_params *qp, struct query_clause *qc)
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
{
char *count;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *query;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f JOIN playlistitems pi ON f.path = pi.filepath %s AND pi.playlistid = %d;", qc->where, qp->id);
query = sqlite3_mprintf("SELECT f.* FROM files f JOIN playlistitems pi ON f.path = pi.filepath %s AND pi.playlistid = %d ORDER BY pi.id ASC %s;", qc->where, qp->id, qc->index);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
}
Implement sorting for smart playlists queries This will be used by the Title view in Remote.
2010-08-03 17:29:16 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
db_build_query_plitems_smart(struct query_params *qp, struct playlist_info *pli)
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
{
struct query_clause *qc;
char *count;
char *query;
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
bool free_orderby = false;
if (pli->query_limit > 0)
{
if (qp->idx_type == I_SUB)
{
if (pli->query_limit > qp->offset + qp->limit)
qp->limit = pli->query_limit;
}
else if (qp->idx_type == I_NONE)
{
qp->idx_type = I_SUB;
qp->limit = pli->query_limit;
qp->offset = 0;
}
else
{
DPRINTF(E_WARN, L_DB, "Cannot append limit from smart playlist '%s' to query\n", pli->path);
}
}
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
if (pli->query_order)
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
{
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
if (!qp->order && qp->sort == S_NONE)
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
{
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
qp->order = strdup(pli->query_order);
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
free_orderby = true;
}
else
DPRINTF(E_WARN, L_DB, "Cannot append order by from smart playlist '%s' to query\n", pli->path);
}
Fix memory leak if index clause is used
2015-09-26 03:28:20 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
qc = db_build_query_clause(qp);
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
if (free_orderby)
{
Unify naming of "order by" clause in structs/table
2018-04-15 02:03:42 -04:00
free(qp->order);
qp->order = NULL;
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
if (!qc)
return NULL;
Fix memory leak if index clause is used
2015-09-26 03:28:20 -04:00
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f %s AND %s LIMIT %d;", qc->where, pli->query, pli->query_limit);
query = sqlite3_mprintf("SELECT f.* FROM files f %s AND %s %s %s;", qc->where, pli->query, qc->order, qc->index);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
db_free_query_clause(qc);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_plitems(struct query_params *qp, struct query_clause *qc)
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
{
struct playlist_info *pli;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *query;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
Rename pl_id member of struct query_params
2010-03-07 05:53:16 -05:00
if (qp->id <= 0)
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
{
DPRINTF(E_LOG, L_DB, "No playlist id specified in playlist items query\n");
return NULL;
}
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
Rename pl_id member of struct query_params
2010-03-07 05:53:16 -05:00
pli = db_pl_fetch_byid(qp->id);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
if (!pli)
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return NULL;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
switch (pli->type)
{
[smartpl] refactoring: repurpose playlist type PL_SMART for user created smart playlists and introduce new type PL_SPECIAL for special system playlists
2015-04-11 10:55:13 -04:00
case PL_SPECIAL:
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
case PL_SMART:
[db/filescanner] Upgrade database to v19.08 and support limit/order by in smart playlist files
2018-04-13 10:29:06 -04:00
query = db_build_query_plitems_smart(qp, pli);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
break;
case PL_PLAIN:
Adds a playlist folder type, it is needed for sorting since some clients (eg Retune) require that playlist folders are sent before their content. Playlist folders should, however, be sent after the base playlists, so the numbering is changed. At the same time makes the value of the smart playlist type a bit less hardcoded.
2015-03-29 19:03:15 -04:00
case PL_FOLDER:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_plitems_plain(qp, qc);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
break;
default:
DPRINTF(E_LOG, L_DB, "Unknown playlist type %d in playlist items query\n", pli->type);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
query = NULL;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
break;
}
free_pli(pli, 0);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return query;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_group_albums(struct query_params *qp, struct query_clause *qc)
Add database code for groups queries
2010-01-10 06:26:48 -05:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *count;
Add database code for groups queries
2010-01-10 06:26:48 -05:00
char *query;
[db] Fix total results for album group query The query did not respect the filter and therefor always returned the number of albums in the library and not the number of albums for the given query.
2018-03-17 15:20:19 -04:00
count = sqlite3_mprintf("SELECT COUNT(DISTINCT f.songalbumid) FROM files f %s;", qc->where);
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
query = sqlite3_mprintf("SELECT g.id, g.persistentid, f.album, f.album_sort, COUNT(f.id) as track_count, 1 as album_count, f.album_artist, f.songartistid, SUM(f.song_length) FROM files f JOIN groups g ON f.songalbumid = g.persistentid %s GROUP BY f.songalbumid %s %s %s;", qc->where, qc->having, qc->order, qc->index);
Add database code for groups queries
2010-01-10 06:26:48 -05:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add database code for groups queries
2010-01-10 06:26:48 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_group_artists(struct query_params *qp, struct query_clause *qc)
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
{
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *count;
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
char *query;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(DISTINCT f.songartistid) FROM files f %s;", qc->where);
[db] Add support for ORDER BY and HAVING clause in query parameter
2018-03-17 08:27:59 -04:00
query = sqlite3_mprintf("SELECT g.id, g.persistentid, f.album_artist, f.album_artist_sort, COUNT(f.id) as track_count, COUNT(DISTINCT f.songalbumid) as album_count, f.album_artist, f.songartistid, SUM(f.song_length) FROM files f JOIN groups g ON f.songartistid = g.persistentid %s GROUP BY f.songartistid %s %s %s;", qc->where, qc->having, qc->order, qc->index);
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_group_items(struct query_params *qp, struct query_clause *qc)
Add groups queries
2010-03-07 06:53:23 -05:00
{
enum group_type gt;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *count;
char *query;
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
gt = db_group_type_bypersistentid(qp->persistentid);
Add groups queries
2010-03-07 06:53:23 -05:00
switch (gt)
{
case G_ALBUMS:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f %s AND f.songalbumid = %" PRIi64 ";", qc->where, qp->persistentid);
query = sqlite3_mprintf("SELECT f.* FROM files f %s AND f.songalbumid = %" PRIi64 " %s %s;", qc->where, qp->persistentid, qc->order, qc->index);
Add groups queries
2010-03-07 06:53:23 -05:00
break;
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
case G_ARTISTS:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f %s AND f.songartistid = %" PRIi64 ";", qc->where, qp->persistentid);
query = sqlite3_mprintf("SELECT f.* FROM files f %s AND f.songartistid = %" PRIi64 " %s %s;", qc->where, qp->persistentid, qc->order, qc->index);
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
break;
Add groups queries
2010-03-07 06:53:23 -05:00
default:
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %" PRIi64 "\n", gt, qp->persistentid);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return NULL;
Add groups queries
2010-03-07 06:53:23 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add groups queries
2010-03-07 06:53:23 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_group_dirs(struct query_params *qp, struct query_clause *qc)
Add groups queries
2010-03-07 06:53:23 -05:00
{
enum group_type gt;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *count;
char *query;
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
gt = db_group_type_bypersistentid(qp->persistentid);
Add groups queries
2010-03-07 06:53:23 -05:00
switch (gt)
{
case G_ALBUMS:
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
count = sqlite3_mprintf("SELECT COUNT(DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1)))"
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
" FROM files f %s AND f.songalbumid = %" PRIi64 ";", qc->where, qp->persistentid);
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
query = sqlite3_mprintf("SELECT DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1))"
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
" FROM files f %s AND f.songalbumid = %" PRIi64 " %s %s;", qc->where, qp->persistentid, qc->order, qc->index);
Add groups queries
2010-03-07 06:53:23 -05:00
break;
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
case G_ARTISTS:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
count = sqlite3_mprintf("SELECT COUNT(DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1)))"
" FROM files f %s AND f.songartistid = %" PRIi64 ";", qc->where, qp->persistentid);
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
query = sqlite3_mprintf("SELECT DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1))"
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
" FROM files f %s AND f.songartistid = %" PRIi64 " %s %s;", qc->where, qp->persistentid, qc->order, qc->index);
Upgrade database to version 14 (artist groups and seek) - add songartistid to support artist groups - add corresponding trigger - add seek field for later use (to save playback position) - add G_ARTISTS and adjust queries - add smart playlists Podcasts/Audiobooks with db upgrade
2013-12-17 14:58:55 -05:00
break;
default:
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %" PRIi64 "\n", gt, qp->persistentid);
return NULL;
Add groups queries
2010-03-07 06:53:23 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add groups queries
2010-03-07 06:53:23 -05:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_browse(struct query_params *qp, struct query_clause *qc)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
const char *where;
const char *select;
Add new database code
2009-06-07 12:56:35 -04:00
char *count;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
char *query;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
select = browse_clause[qp->type & ~Q_F_BROWSE].select;
where = browse_clause[qp->type & ~Q_F_BROWSE].where;
[db] Fix count error in db_build_query_browse() if no items match query
2018-09-22 19:37:40 -04:00
count = sqlite3_mprintf("SELECT COUNT(*) FROM (SELECT %s FROM files f %s AND %s != '' %s);", select, qc->where, where, qc->group);
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
query = sqlite3_mprintf("SELECT %s FROM files f %s AND %s != '' %s %s %s;", select, qc->where, where, qc->group, qc->order, qc->index);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return db_build_query_check(qp, count, query);
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
static char *
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_build_query_count_items(struct query_params *qp, struct query_clause *qc)
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
{
char *query;
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
qp->results = 1;
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
[jsonapi] Add cache control header to count endpoint and fix not-modified-since check to check against the last db update instead of last start time
2018-04-27 00:42:57 -04:00
query = sqlite3_mprintf("SELECT COUNT(*), SUM(song_length), COUNT(DISTINCT songartistid), COUNT(DISTINCT songalbumid) FROM files f %s;", qc->where);
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
if (!query)
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
return query;
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
}
Add new database code
2009-06-07 12:56:35 -04:00
int
db_query_start(struct query_params *qp)
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
struct query_clause *qc;
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
sqlite3_stmt *stmt;
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
int ret;
qp->stmt = NULL;
[db] Add a free_query_params function
2017-10-25 17:32:16 -04:00
qp->results = -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
qc = db_build_query_clause(qp);
if (!qc)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
switch (qp->type)
{
case Q_ITEMS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_items(qp, qc);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case Q_PL:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_pls(qp, qc);
Add new database code
2009-06-07 12:56:35 -04:00
break;
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
case Q_FIND_PL:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_find_pls(qp, qc);
[artwork] Add handler for playlist local artwork (for http items) - ref https://www.raspberrypi.org/forums/viewtopic.php?p=1090166#p1090166
2017-01-04 17:20:59 -05:00
break;
Add new database code
2009-06-07 12:56:35 -04:00
case Q_PLITEMS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_plitems(qp, qc);
Add new database code
2009-06-07 12:56:35 -04:00
break;
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
case Q_GROUP_ALBUMS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_group_albums(qp, qc);
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
break;
case Q_GROUP_ARTISTS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_group_artists(qp, qc);
Add database code for groups queries
2010-01-10 06:26:48 -05:00
break;
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
case Q_GROUP_ITEMS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_group_items(qp, qc);
Add groups queries
2010-03-07 06:53:23 -05:00
break;
case Q_GROUP_DIRS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_group_dirs(qp, qc);
Add groups queries
2010-03-07 06:53:23 -05:00
break;
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
case Q_COUNT_ITEMS:
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_count_items(qp, qc);
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
break;
Add new database code
2009-06-07 12:56:35 -04:00
default:
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
if (qp->type & Q_F_BROWSE)
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = db_build_query_browse(qp, qc);
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
else
query = NULL;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_free_query_clause(qc);
[db] Refactor db_build_query_* to reduce redundancy
2017-01-04 16:29:47 -05:00
if (!query)
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
{
DPRINTF(E_LOG, L_DB, "Could not create query, unknown type %d\n", qp->type);
return -1;
}
Add new database code
2009-06-07 12:56:35 -04:00
DPRINTF(E_DBG, L_DB, "Starting query '%s'\n", query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
qp->stmt = stmt;
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
void
db_query_end(struct query_params *qp)
{
if (!qp->stmt)
return;
sqlite3_finalize(qp->stmt);
qp->stmt = NULL;
}
[cache/scan] Let notifications from db.c about library updates go through filescanner/listener instead of directly to the cache
2017-01-07 18:21:47 -05:00
/*
* Utility function for running write queries (INSERT, UPDATE, DELETE). If you
* set free to non-zero, the function will free the query. If you set
* library_update to non-zero it means that the update was not just of some
* internal value (like a timestamp), but of something that requires clients
* to update their cache of the library (and of course also of our own cache).
*/
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
static int
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(char *query, int free, short update_events)
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
{
char *errmsg;
[db] Only trigger the library update callback, if a query changed at least one row
2017-11-12 04:46:05 -05:00
int changes = 0;
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
int ret;
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Avoid cache regeneration triggering during db_query_run (in case the query is long running, like db_files_update_songalbumid might be)
2015-06-08 17:07:56 -04:00
/* If the query will be long running we don't want the cache to start regenerating */
cache_daap_suspend();
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
DPRINTF(E_LOG, L_DB, "Error '%s' while runnning '%s'\n", errmsg, query);
[db] Only trigger the library update callback, if a query changed at least one row
2017-11-12 04:46:05 -05:00
else
changes = sqlite3_changes(hdl);
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
sqlite3_free(errmsg);
if (free)
sqlite3_free(query);
[cache/scan] Let notifications from db.c about library updates go through filescanner/listener instead of directly to the cache
2017-01-07 18:21:47 -05:00
cache_daap_resume();
Rework user rating updates
2017-12-09 11:12:13 -05:00
if (update_events && changes > 0)
library_update_trigger(update_events);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
return ((ret != SQLITE_OK) ? -1 : 0);
}
Add new database code
2009-06-07 12:56:35 -04:00
int
db_query_fetch_file(struct query_params *qp, struct db_media_file_info *dbmfi)
{
int ncols;
char **strcol;
int i;
int ret;
memset(dbmfi, 0, sizeof(struct db_media_file_info));
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
if ((qp->type != Q_ITEMS) && (qp->type != Q_PLITEMS) && (qp->type != Q_GROUP_ITEMS))
Add new database code
2009-06-07 12:56:35 -04:00
{
Add groups queries
2010-03-07 06:53:23 -05:00
DPRINTF(E_LOG, L_DB, "Not an items, playlist or group items query!\n");
Add new database code
2009-06-07 12:56:35 -04:00
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(qp->stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret == SQLITE_DONE)
{
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "End of query results\n");
Add new database code
2009-06-07 12:56:35 -04:00
dbmfi->id = NULL;
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
ncols = sqlite3_column_count(qp->stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
// We allow more cols in db than in map because the db may be a future schema
if (ncols < ARRAY_SIZE(dbmfi_cols_map))
Add new database code
2009-06-07 12:56:35 -04:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than dbmfi column map (%u)\n", ncols, ARRAY_SIZE(dbmfi_cols_map));
Add new database code
2009-06-07 12:56:35 -04:00
return -1;
}
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
for (i = 0; i < ARRAY_SIZE(dbmfi_cols_map); i++)
Add new database code
2009-06-07 12:56:35 -04:00
{
strcol = (char **) ((char *)dbmfi + dbmfi_cols_map[i]);
*strcol = (char *)sqlite3_column_text(qp->stmt, i);
}
return 0;
}
int
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_query_fetch_pl(struct query_params *qp, struct db_playlist_info *dbpli)
Add new database code
2009-06-07 12:56:35 -04:00
{
int ncols;
char **strcol;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
uint32_t nitems;
uint32_t nstreams;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
int type;
Add new database code
2009-06-07 12:56:35 -04:00
int i;
int ret;
memset(dbpli, 0, sizeof(struct db_playlist_info));
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
[db] Forgot to add Q_FIND_PL as a playlist query
2017-01-06 13:58:38 -05:00
if ((qp->type != Q_PL) && (qp->type != Q_FIND_PL))
Add new database code
2009-06-07 12:56:35 -04:00
{
DPRINTF(E_LOG, L_DB, "Not a playlist query!\n");
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(qp->stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret == SQLITE_DONE)
{
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "End of query results\n");
Add new database code
2009-06-07 12:56:35 -04:00
dbpli->id = NULL;
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
ncols = sqlite3_column_count(qp->stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
// We allow more cols in db than in map because the db may be a future schema
if (ncols < ARRAY_SIZE(dbpli_cols_map))
Add new database code
2009-06-07 12:56:35 -04:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than dbpli column map (%u)\n", ncols, ARRAY_SIZE(dbpli_cols_map));
Add new database code
2009-06-07 12:56:35 -04:00
return -1;
}
[db] Allow fetching playlists if the schema contains more columns than the column map (can happen if there was a minor db version upgrade)
2018-04-14 04:40:48 -04:00
for (i = 0; i < ARRAY_SIZE(dbpli_cols_map); i++)
Add new database code
2009-06-07 12:56:35 -04:00
{
strcol = (char **) ((char *)dbpli + dbpli_cols_map[i]);
*strcol = (char *)sqlite3_column_text(qp->stmt, i);
}
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
type = sqlite3_column_int(qp->stmt, 2);
if (type == PL_SPECIAL || type == PL_SMART)
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_files_get_count(&nitems, &nstreams, dbpli->query);
snprintf(qp->buf1, sizeof(qp->buf1), "%d", (int)nitems);
snprintf(qp->buf2, sizeof(qp->buf2), "%d", (int)nstreams);
[db] Make loading of playlistitem count optional
2016-02-21 12:05:11 -05:00
dbpli->items = qp->buf1;
dbpli->streams = qp->buf2;
Count playlist items on the fly
2009-06-11 12:28:01 -04:00
}
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
Add database code for groups queries
2010-01-10 06:26:48 -05:00
int
db_query_fetch_group(struct query_params *qp, struct db_group_info *dbgri)
{
int ncols;
char **strcol;
int i;
int ret;
memset(dbgri, 0, sizeof(struct db_group_info));
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
Add support for artist group request (experimental) The purpose of this is mainly to support Hyperfine Remote for Android
2013-08-29 16:00:37 -04:00
if ((qp->type != Q_GROUP_ALBUMS) && (qp->type != Q_GROUP_ARTISTS))
Add database code for groups queries
2010-01-10 06:26:48 -05:00
{
DPRINTF(E_LOG, L_DB, "Not a groups query!\n");
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(qp->stmt);
Add database code for groups queries
2010-01-10 06:26:48 -05:00
if (ret == SQLITE_DONE)
{
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "End of query results\n");
Add database code for groups queries
2010-01-10 06:26:48 -05:00
return 1;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
ncols = sqlite3_column_count(qp->stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
// We allow more cols in db than in map because the db may be a future schema
if (ncols < ARRAY_SIZE(dbgri_cols_map))
Add database code for groups queries
2010-01-10 06:26:48 -05:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than dbgri column map (%u)\n", ncols, ARRAY_SIZE(dbgri_cols_map));
Add database code for groups queries
2010-01-10 06:26:48 -05:00
return -1;
}
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
for (i = 0; i < ARRAY_SIZE(dbgri_cols_map); i++)
Add database code for groups queries
2010-01-10 06:26:48 -05:00
{
strcol = (char **) ((char *)dbgri + dbgri_cols_map[i]);
*strcol = (char *)sqlite3_column_text(qp->stmt, i);
}
return 0;
}
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
int
Rename count_info to fix issue #157
2015-05-26 15:24:10 -04:00
db_query_fetch_count(struct query_params *qp, struct filecount_info *fci)
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
{
int ret;
Rename count_info to fix issue #157
2015-05-26 15:24:10 -04:00
memset(fci, 0, sizeof(struct filecount_info));
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
if (qp->type != Q_COUNT_ITEMS)
{
DPRINTF(E_LOG, L_DB, "Not a count query!\n");
return -1;
}
ret = db_blocking_step(qp->stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of query results for count query\n");
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
Rename count_info to fix issue #157
2015-05-26 15:24:10 -04:00
fci->count = sqlite3_column_int(qp->stmt, 0);
[mpd] Fix wrong db playime info in 'stats' command (#360)
2017-03-04 11:23:52 -05:00
fci->length = sqlite3_column_int64(qp->stmt, 1);
[db/mpd/jsonapi] Include artist and album count in filecount query; add count endpoint and additional metadata to JSON API; remove unused artist-/album-count queries
2018-04-22 02:40:23 -04:00
fci->artist_count = sqlite3_column_int(qp->stmt, 2);
fci->album_count = sqlite3_column_int(qp->stmt, 3);
[mpd] add support for count command
2015-04-06 03:19:48 -04:00
return 0;
}
[db/mpd] Simplify getting file count from db
2017-08-12 10:47:44 -04:00
int
db_filecount_get(struct filecount_info *fci, struct query_params *qp)
{
int ret;
ret = db_query_start(qp);
if (ret < 0)
{
db_query_end(qp);
return -1;
}
ret = db_query_fetch_count(qp, fci);
if (ret < 0)
{
db_query_end(qp);
return -1;
}
db_query_end(qp);
return 0;
}
Add new database code
2009-06-07 12:56:35 -04:00
int
db_query_fetch_string(struct query_params *qp, char **string)
{
int ret;
*string = NULL;
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(qp->stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret == SQLITE_DONE)
{
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "End of query results\n");
Add new database code
2009-06-07 12:56:35 -04:00
*string = NULL;
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
*string = (char *)sqlite3_column_text(qp->stmt, 0);
return 0;
}
Add db_query_fetch_string_sort() to fetch string+sortstring results
2010-12-05 10:27:06 -05:00
int
db_query_fetch_string_sort(struct query_params *qp, char **string, char **sortstring)
{
int ret;
*string = NULL;
if (!qp->stmt)
{
DPRINTF(E_LOG, L_DB, "Query not started!\n");
return -1;
}
if (!(qp->type & Q_F_BROWSE))
{
DPRINTF(E_LOG, L_DB, "Not a browse query!\n");
return -1;
}
ret = db_blocking_step(qp->stmt);
if (ret == SQLITE_DONE)
{
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "End of query results\n");
Add db_query_fetch_string_sort() to fetch string+sortstring results
2010-12-05 10:27:06 -05:00
*string = NULL;
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
*string = (char *)sqlite3_column_text(qp->stmt, 0);
*sortstring = (char *)sqlite3_column_text(qp->stmt, 1);
return 0;
}
Add new database code
2009-06-07 12:56:35 -04:00
/* Files */
int
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_files_get_count(uint32_t *nitems, uint32_t *nstreams, const char *filter)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
sqlite3_stmt *stmt;
char *query;
int ret;
if (!filter && !nstreams)
query = sqlite3_mprintf("SELECT COUNT(*) FROM files f WHERE f.disabled = 0;");
else if (!filter)
query = sqlite3_mprintf("SELECT COUNT(*), SUM(data_kind = %d) FROM files f WHERE f.disabled = 0;", DATA_KIND_HTTP);
else if (!nstreams)
query = sqlite3_mprintf("SELECT COUNT(*) FROM files f WHERE f.disabled = 0 AND %s;", filter);
else
query = sqlite3_mprintf("SELECT COUNT(*), SUM(data_kind = %d) FROM files f WHERE f.disabled = 0 AND %s;", DATA_KIND_HTTP, filter);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
sqlite3_free(query);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
return -1;
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
DPRINTF(E_INFO, L_DB, "No matching row found for query: %s\n", query);
else
DPRINTF(E_LOG, L_DB, "Could not step: %s (%s)\n", sqlite3_errmsg(hdl), query);
sqlite3_finalize(stmt);
return -1;
}
if (nitems)
*nitems = sqlite3_column_int(stmt, 0);
if (nstreams)
*nstreams = sqlite3_column_int(stmt, 1);
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
sqlite3_finalize(stmt);
return 0;
Add new database code
2009-06-07 12:56:35 -04:00
}
void
db_file_inc_playcount(int id)
{
Enable resuming playback from saved position for certain media kinds (eg audiobooks)
2015-08-04 16:33:32 -04:00
#define Q_TMPL "UPDATE files SET play_count = play_count + 1, time_played = %" PRIi64 ", seek = 0 WHERE id = %d;"
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
/*
* Rating calculation is taken from from the beets plugin "mpdstats" (see https://beets.readthedocs.io/en/latest/plugins/mpdstats.html)
* and adapted to the forked-daapd rating rage (0 to 100).
*
* Rating consist of the stable rating and a rolling rating.
* The stable rating is calculated based on the number was played and skipped:
* stable rating = (play_count + 1.0) / (play_count + skip_count + 2.0) * 100
* The rolling rating is calculated based on the current action (played or skipped):
* rolling rating for played = rating + ((100.0 - rating) / 2.0)
* rolling rating for skipped = rating - (rating / 2.0)
*
* The new rating is a mix of stable and rolling rating (factor 0.75):
* new rating = stable rating * 0.75 + rolling rating * 0.25
*/
#define Q_TMPL_WITH_RATING \
"UPDATE files "\
" SET play_count = play_count + 1, time_played = %" PRIi64 ", seek = 0, "\
" rating = CAST(((play_count + 1.0) / (play_count + skip_count + 2.0) * 100 * 0.75) + ((rating + ((100.0 - rating) / 2.0)) * 0.25) AS INT)" \
" WHERE id = %d;"
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
int ret;
Add new database code
2009-06-07 12:56:35 -04:00
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
if (db_rating_updates)
query = sqlite3_mprintf(Q_TMPL_WITH_RATING, (int64_t)time(NULL), id);
else
query = sqlite3_mprintf(Q_TMPL, (int64_t)time(NULL), id);
Add new database code
2009-06-07 12:56:35 -04:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
db_admin_setint64(DB_ADMIN_DB_MODIFIED, (int64_t) time(NULL));
Add new database code
2009-06-07 12:56:35 -04:00
#undef Q_TMPL
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
#undef Q_TMPL_WITH_RATING
Add new database code
2009-06-07 12:56:35 -04:00
}
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
void
db_file_inc_skipcount(int id)
{
#define Q_TMPL "UPDATE files SET skip_count = skip_count + 1, time_skipped = %" PRIi64 " WHERE id = %d;"
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
// see db_file_inc_playcount for a description of how the rating is calculated
#define Q_TMPL_WITH_RATING \
"UPDATE files "\
" SET skip_count = skip_count + 1, time_skipped = %" PRIi64 ", seek = 0, "\
" rating = CAST(((play_count + 1.0) / (play_count + skip_count + 2.0) * 100 * 0.75) + ((rating - (rating / 2.0)) * 0.25) AS INT)" \
" WHERE id = %d;"
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
char *query;
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
int ret;
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
if (db_rating_updates)
query = sqlite3_mprintf(Q_TMPL_WITH_RATING, (int64_t)time(NULL), id);
else
query = sqlite3_mprintf(Q_TMPL, (int64_t)time(NULL), id);
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
db_admin_setint64(DB_ADMIN_DB_MODIFIED, (int64_t) time(NULL));
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
#undef Q_TMPL
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
#undef Q_TMPL_WITH_RATING
Support for skip_count and time_skipped file metadata
2018-08-18 16:56:27 -04:00
}
[db] Add support for resetting play- and skip-count
2019-01-23 03:25:34 -05:00
void
db_file_reset_playskip_count(int id)
{
#define Q_TMPL "UPDATE files SET play_count = 0, skip_count = 0, time_played = 0, time_skipped = 0 WHERE id = %d;"
char *query;
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
int ret;
[db] Add support for resetting play- and skip-count
2019-01-23 03:25:34 -05:00
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
db_admin_setint64(DB_ADMIN_DB_MODIFIED, (int64_t) time(NULL));
[db] Add support for resetting play- and skip-count
2019-01-23 03:25:34 -05:00
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
void
Speedup startup rescan
2011-06-12 05:06:37 -04:00
db_file_ping(int id)
Add new database code
2009-06-07 12:56:35 -04:00
{
Speedup startup rescan
2011-06-12 05:06:37 -04:00
#define Q_TMPL "UPDATE files SET db_timestamp = %" PRIi64 ", disabled = 0 WHERE id = %d;"
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
Speedup startup rescan
2011-06-12 05:06:37 -04:00
query = sqlite3_mprintf(Q_TMPL, (int64_t)time(NULL), id);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Review of cache regeneration triggers
2016-12-18 15:18:15 -05:00
db_query_run(query, 1, 0);
Add new database code
2009-06-07 12:56:35 -04:00
#undef Q_TMPL
}
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
int
db_file_ping_bypath(const char *path, time_t mtime_max)
{
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
sqlite3_bind_int64(db_statements.files_ping, 1, (int64_t)time(NULL));
sqlite3_bind_text(db_statements.files_ping, 2, path, -1, SQLITE_STATIC);
sqlite3_bind_int64(db_statements.files_ping, 3, (int64_t)mtime_max);
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
return db_statement_run(db_statements.files_ping);
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
}
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
void
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_ping_bymatch(const char *path, int isdir)
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
{
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
#define Q_TMPL_DIR "UPDATE files SET db_timestamp = %" PRIi64 " WHERE path LIKE '%q/%%';"
#define Q_TMPL_NODIR "UPDATE files SET db_timestamp = %" PRIi64 " WHERE path LIKE '%q%%';"
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
char *query;
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
if (isdir)
query = sqlite3_mprintf(Q_TMPL_DIR, (int64_t)time(NULL), path);
else
query = sqlite3_mprintf(Q_TMPL_NODIR, (int64_t)time(NULL), path);
[db] Review of cache regeneration triggers
2016-12-18 15:18:15 -05:00
db_query_run(query, 1, 0);
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
#undef Q_TMPL_DIR
#undef Q_TMPL_NODIR
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
}
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
char *
db_file_path_byid(int id)
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT f.path FROM files f WHERE f.id = %d;"
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
char *query;
sqlite3_stmt *stmt;
char *res;
int ret;
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, strlen(query) + 1, &stmt, NULL);
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return NULL;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "No results\n");
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
else
db: fix wrong number of elements for purge queries
2015-02-23 14:26:42 -05:00
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
sqlite3_finalize(stmt);
sqlite3_free(query);
return NULL;
}
res = (char *)sqlite3_column_text(stmt, 0);
if (res)
res = strdup(res);
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add db_file_path_byid()
2010-03-07 05:06:15 -05:00
sqlite3_finalize(stmt);
sqlite3_free(query);
return res;
#undef Q_TMPL
}
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
static int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_id_byquery(const char *query)
Add new database code
2009-06-07 12:56:35 -04:00
{
sqlite3_stmt *stmt;
int ret;
if (!query)
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
return 0;
Add new database code
2009-06-07 12:56:35 -04:00
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, strlen(query) + 1, &stmt, NULL);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
Rework process_media_file() and related DB support routines Avoid pulling all the file info from the DB in process_media_file() as anything besides the file id and timestamp is not used at all.
2009-06-11 14:44:22 -04:00
return 0;
Add new database code
2009-06-07 12:56:35 -04:00
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "No results\n");
Add new database code
2009-06-07 12:56:35 -04:00
else
db: fix wrong number of elements for purge queries
2015-02-23 14:26:42 -05:00
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
Rework process_media_file() and related DB support routines Avoid pulling all the file info from the DB in process_media_file() as anything besides the file id and timestamp is not used at all.
2009-06-11 14:44:22 -04:00
return 0;
Add new database code
2009-06-07 12:56:35 -04:00
}
Rework process_media_file() and related DB support routines Avoid pulling all the file info from the DB in process_media_file() as anything besides the file id and timestamp is not used at all.
2009-06-11 14:44:22 -04:00
ret = sqlite3_column_int(stmt, 0);
Add new database code
2009-06-07 12:56:35 -04:00
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
return ret;
}
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_id_bypath(const char *path)
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT f.id FROM files f WHERE f.path = '%q';"
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path);
Introduce db_file_id_byfilebase and db_file_id_byfile File id lookup by basepath + filename and filename only.
2009-11-22 10:30:45 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_id_byfile(const char *filename)
Introduce db_file_id_byfilebase and db_file_id_byfile File id lookup by basepath + filename and filename only.
2009-11-22 10:30:45 -05:00
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT f.id FROM files f WHERE f.fname = '%q';"
Introduce db_file_id_byfilebase and db_file_id_byfile File id lookup by basepath + filename and filename only.
2009-11-22 10:30:45 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, filename);
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_id_byurl(const char *url)
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT f.id FROM files f WHERE f.url = '%q';"
Introduce db_file_id_byurl and share code with db_file_id_bypath
2009-11-22 09:39:38 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, url);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_free(query);
Rework process_media_file() and related DB support routines Avoid pulling all the file info from the DB in process_media_file() as anything besides the file id and timestamp is not used at all.
2009-06-11 14:44:22 -04:00
return ret;
#undef Q_TMPL
}
[mpd] support serving artwork over http
2015-07-16 21:22:24 -04:00
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_id_by_virtualpath_match(const char *path)
[mpd] support serving artwork over http
2015-07-16 21:22:24 -04:00
{
#define Q_TMPL "SELECT f.id FROM files f WHERE f.virtual_path LIKE '%%%q%%';"
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
static struct media_file_info *
db_file_fetch_byquery(char *query)
{
struct media_file_info *mfi;
sqlite3_stmt *stmt;
int ncols;
char *cval;
uint32_t *ival;
uint64_t *i64val;
char **strval;
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
uint64_t disabled;
Add new database code
2009-06-07 12:56:35 -04:00
int i;
int ret;
if (!query)
return NULL;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
mfi = calloc(1, sizeof(struct media_file_info));
Add new database code
2009-06-07 12:56:35 -04:00
if (!mfi)
{
DPRINTF(E_LOG, L_DB, "Could not allocate struct media_file_info, out of memory\n");
return NULL;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
free(mfi);
return NULL;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "No results\n");
Add new database code
2009-06-07 12:56:35 -04:00
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
free(mfi);
return NULL;
}
ncols = sqlite3_column_count(stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
// We allow more cols in db than in map because the db may be a future schema
if (ncols < ARRAY_SIZE(mfi_cols_map))
Add new database code
2009-06-07 12:56:35 -04:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than mfi column map (%u)\n", ncols, ARRAY_SIZE(mfi_cols_map));
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
free(mfi);
return NULL;
}
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
for (i = 0; i < ARRAY_SIZE(mfi_cols_map); i++)
Add new database code
2009-06-07 12:56:35 -04:00
{
switch (mfi_cols_map[i].type)
{
case DB_TYPE_INT:
ival = (uint32_t *) ((char *)mfi + mfi_cols_map[i].offset);
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
if (mfi_cols_map[i].offset == mfi_offsetof(disabled))
{
disabled = sqlite3_column_int64(stmt, i);
*ival = (disabled != 0);
}
else
*ival = sqlite3_column_int(stmt, i);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case DB_TYPE_INT64:
i64val = (uint64_t *) ((char *)mfi + mfi_cols_map[i].offset);
*i64val = sqlite3_column_int64(stmt, i);
break;
case DB_TYPE_STRING:
strval = (char **) ((char *)mfi + mfi_cols_map[i].offset);
cval = (char *)sqlite3_column_text(stmt, i);
if (cval)
*strval = strdup(cval);
break;
default:
DPRINTF(E_LOG, L_DB, "BUG: Unknown type %d in mfi column map\n", mfi_cols_map[i].type);
free_mfi(mfi, 0);
sqlite3_finalize(stmt);
return NULL;
}
}
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
return mfi;
}
struct media_file_info *
db_file_fetch_byid(int id)
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT f.* FROM files f WHERE f.id = %d;"
Add new database code
2009-06-07 12:56:35 -04:00
struct media_file_info *mfi;
char *query;
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
mfi = db_file_fetch_byquery(query);
sqlite3_free(query);
return mfi;
#undef Q_TMPL
}
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
struct media_file_info *
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
db_file_fetch_byvirtualpath(const char *virtual_path)
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
{
#define Q_TMPL "SELECT f.* FROM files f WHERE f.virtual_path = %Q;"
struct media_file_info *mfi;
char *query;
query = sqlite3_mprintf(Q_TMPL, virtual_path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
mfi = db_file_fetch_byquery(query);
sqlite3_free(query);
return mfi;
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
int
db_file_add(struct media_file_info *mfi)
{
int ret;
if (mfi->id != 0)
{
Fix error message in db_file_add()
2010-04-30 12:28:29 -04:00
DPRINTF(E_WARN, L_DB, "Trying to add file with non-zero id; use db_file_update()?\n");
Add new database code
2009-06-07 12:56:35 -04:00
return -1;
}
mfi->db_timestamp = (uint64_t)time(NULL);
[spotify] Improve Spotify loading efficiency and set time_added so smart playlists will work
2015-05-29 13:47:53 -04:00
[db] Fix for time_added incorrectly updated (issue #852)
2019-12-03 12:24:39 -05:00
// We don't do this in fixup_tags_mfi() to avoid affecting db_file_update()
if (mfi->time_added == 0)
mfi->time_added = mfi->db_timestamp;
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
fixup_tags_mfi(mfi);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
ret = bind_mfi(db_statements.files_insert, mfi);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
ret = db_statement_run(db_statements.files_insert);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
library_update_trigger(LISTENER_DATABASE);
Some more daap cache triggers
2014-08-21 04:14:24 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
int
db_file_update(struct media_file_info *mfi)
{
int ret;
if (mfi->id == 0)
{
DPRINTF(E_WARN, L_DB, "Trying to update file with id 0; use db_file_add()?\n");
return -1;
}
mfi->db_timestamp = (uint64_t)time(NULL);
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
fixup_tags_mfi(mfi);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
ret = bind_mfi(db_statements.files_update, mfi);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
ret = db_statement_run(db_statements.files_update);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
library_update_trigger(LISTENER_DATABASE);
Add DAAP cache backend
2014-08-19 18:21:48 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
Enable resuming playback from saved position for certain media kinds (eg audiobooks)
2015-08-04 16:33:32 -04:00
void
[db] Rename db_file_save_seek -> db_file_seek_update
2017-01-15 17:22:06 -05:00
db_file_seek_update(int id, uint32_t seek)
Enable resuming playback from saved position for certain media kinds (eg audiobooks)
2015-08-04 16:33:32 -04:00
{
#define Q_TMPL "UPDATE files SET seek = %d WHERE id = %d;"
char *query;
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
int ret;
Enable resuming playback from saved position for certain media kinds (eg audiobooks)
2015-08-04 16:33:32 -04:00
if (id == 0)
return;
query = sqlite3_mprintf(Q_TMPL, seek, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
db_admin_setint64(DB_ADMIN_DB_MODIFIED, (int64_t) time(NULL));
Enable resuming playback from saved position for certain media kinds (eg audiobooks)
2015-08-04 16:33:32 -04:00
#undef Q_TMPL
}
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
static int
db_file_rating_update(char *query)
Rework user rating updates
2017-12-09 11:12:13 -05:00
{
int ret;
[db] Instantly notify about rating changes
2017-12-15 11:12:19 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
{
db_admin_setint64(DB_ADMIN_DB_MODIFIED, (int64_t) time(NULL));
listener_notify(LISTENER_RATING);
}
Rework user rating updates
2017-12-09 11:12:13 -05:00
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
}
int
db_file_rating_update_byid(uint32_t id, uint32_t rating)
{
#define Q_TMPL "UPDATE files SET rating = %d WHERE id = %d;"
char *query;
query = sqlite3_mprintf(Q_TMPL, rating, id);
return db_file_rating_update(query);
Rework user rating updates
2017-12-09 11:12:13 -05:00
#undef Q_TMPL
}
int
db_file_rating_update_byvirtualpath(const char *virtual_path, uint32_t rating)
{
#define Q_TMPL "UPDATE files SET rating = %d WHERE virtual_path = %Q;"
char *query;
query = sqlite3_mprintf(Q_TMPL, rating, virtual_path);
[db/jsonapi] New admin value for Last-Modified in JSON API header This adds a new timestamp value "db_modified" into the admin db table. In addition to the existing "db_update" admin value, this value is also updated if rating, play-/skip-count or seek changes for a media_info_file (files db table). This should improve the caching behavior in clients of the JSON API (especially the player web interface) in refreshing its data if some of this values changes.
2019-01-30 02:36:34 -05:00
return db_file_rating_update(query);
Rework user rating updates
2017-12-09 11:12:13 -05:00
#undef Q_TMPL
}
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
void
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_delete_bypath(const char *path)
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
{
Rename the songs table
2009-06-11 17:03:53 -04:00
#define Q_TMPL "DELETE FROM files WHERE path = '%q';"
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
char *query;
query = sqlite3_mprintf(Q_TMPL, path);
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(query, 1, LISTENER_DATABASE);
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
#undef Q_TMPL
}
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_file_disable_bypath(const char *path, enum strip_type strip, uint32_t cookie)
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
{
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#define Q_TMPL "UPDATE files SET path = substr(path, %d), virtual_path = substr(virtual_path, %d), disabled = %" PRIi64 " WHERE path = '%q';"
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
int vpath_striplen;
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
vpath_striplen = (strip == STRIP_PATH) ? strlen("/file:") + path_striplen : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, vpath_striplen + 1, disabled, path);
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(query, 1, LISTENER_DATABASE);
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
#undef Q_TMPL
}
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_file_disable_bymatch(const char *path, enum strip_type strip, uint32_t cookie)
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
{
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#define Q_TMPL "UPDATE files SET path = substr(path, %d), virtual_path = substr(virtual_path, %d), disabled = %" PRIi64 " WHERE path LIKE '%q/%%';"
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
int vpath_striplen;
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
vpath_striplen = (strip == STRIP_PATH) ? strlen("/file:") + path_striplen : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, vpath_striplen + 1, disabled, path);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(query, 1, LISTENER_DATABASE);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
#undef Q_TMPL
}
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
// "path" will be the directory part for directory updates (dir moved) and the
// full path for file updates (file moved). The db will have the filename in
// the path field for the former case (with a "/" prefix), and an empty path
// field for the latter.
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
int
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_file_enable_bycookie(uint32_t cookie, const char *path, const char *filename)
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
{
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
#define Q_TMPL_UPDATE_FNAME "UPDATE files SET path = ('%q' || path), virtual_path = ('/file:%q' || virtual_path), fname = '%q', disabled = 0 WHERE disabled = %" PRIi64 ";"
#define Q_TMPL "UPDATE files SET path = ('%q' || path), virtual_path = ('/file:%q' || virtual_path), disabled = 0 WHERE disabled = %" PRIi64 ";"
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
char *query;
int ret;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
if (filename)
query = sqlite3_mprintf(Q_TMPL_UPDATE_FNAME, path, path, filename, (int64_t)cookie);
else
query = sqlite3_mprintf(Q_TMPL, path, path, (int64_t)cookie);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
More DAAP cache adjustments
2014-08-21 17:06:52 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
#undef Q_TMPL_UPDATE_FNAME
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
#undef Q_TMPL
}
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_file_update_directoryid(const char *path, int dir_id)
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
{
#define Q_TMPL "UPDATE files SET directory_id = %d WHERE path = %Q;"
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, dir_id, path);
ret = db_query_run(query, 1, 0);
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
/* Playlists */
int
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_pl_get_count(uint32_t *nitems)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
int ret = db_get_one_int("SELECT COUNT(*) FROM playlists p WHERE p.disabled = 0;");
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
if (ret < 0)
return -1;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
*nitems = (uint32_t)ret;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
return 0;
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
}
Add new database code
2009-06-07 12:56:35 -04:00
void
db_pl_ping(int id)
{
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
#define Q_TMPL "UPDATE playlists SET db_timestamp = %" PRIi64 ", disabled = 0 WHERE id = %d;"
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
query = sqlite3_mprintf(Q_TMPL, (int64_t)time(NULL), id);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Add new database code
2009-06-07 12:56:35 -04:00
#undef Q_TMPL
}
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
void
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_pl_ping_bymatch(const char *path, int isdir)
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
{
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
#define Q_TMPL_DIR "UPDATE playlists SET db_timestamp = %" PRIi64 " WHERE path LIKE '%q/%%';"
#define Q_TMPL_NODIR "UPDATE playlists SET db_timestamp = %" PRIi64 " WHERE path LIKE '%q%%';"
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
char *query;
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
if (isdir)
query = sqlite3_mprintf(Q_TMPL_DIR, (int64_t)time(NULL), path);
else
query = sqlite3_mprintf(Q_TMPL_NODIR, (int64_t)time(NULL), path);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Fix Spotify exemption from purge during init-rescan
2014-05-14 14:44:07 -04:00
#undef Q_TMPL_DIR
#undef Q_TMPL_NODIR
Disable instead of purging when root library dir is not present
2013-11-30 17:12:09 -05:00
}
[db] Add method db_pl_ping_items_bymatch()
2017-10-02 17:02:25 -04:00
void
db_pl_ping_items_bymatch(const char *path, int id)
{
#define Q_TMPL "UPDATE files SET db_timestamp = %" PRIi64 ", disabled = 0 WHERE path IN (SELECT filepath FROM playlistitems WHERE filepath LIKE '%q%%' AND playlistid = %d);"
char *query;
query = sqlite3_mprintf(Q_TMPL, (int64_t)time(NULL), path, id);
db_query_run(query, 1, 0);
#undef Q_TMPL
}
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
int
db_pl_id_bypath(const char *path)
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT p.id FROM playlists p WHERE p.path = '%q';"
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
ret = db_get_one_int(query);
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
sqlite3_free(query);
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
return ret;
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
static struct playlist_info *
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_pl_fetch_byquery(const char *query)
Add new database code
2009-06-07 12:56:35 -04:00
{
struct playlist_info *pli;
sqlite3_stmt *stmt;
int ncols;
char *cval;
uint32_t *ival;
char **strval;
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
uint64_t disabled;
Add new database code
2009-06-07 12:56:35 -04:00
int i;
int ret;
if (!query)
return NULL;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
pli = calloc(1, sizeof(struct playlist_info));
Add new database code
2009-06-07 12:56:35 -04:00
if (!pli)
{
DPRINTF(E_LOG, L_DB, "Could not allocate struct playlist_info, out of memory\n");
return NULL;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
free(pli);
return NULL;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "No results\n");
Add new database code
2009-06-07 12:56:35 -04:00
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
free(pli);
return NULL;
}
ncols = sqlite3_column_count(stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
if (ncols < ARRAY_SIZE(pli_cols_map))
Add new database code
2009-06-07 12:56:35 -04:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than pli column map (%u)\n", ncols, ARRAY_SIZE(pli_cols_map));
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
free(pli);
return NULL;
}
[db] Allow fetching playlists if the schema contains more columns than the column map (can happen if there was a minor db version upgrade)
2018-04-14 04:40:48 -04:00
for (i = 0; i < ARRAY_SIZE(pli_cols_map); i++)
Add new database code
2009-06-07 12:56:35 -04:00
{
switch (pli_cols_map[i].type)
{
case DB_TYPE_INT:
ival = (uint32_t *) ((char *)pli + pli_cols_map[i].offset);
Add support for disabled files and playlists
2009-06-10 09:23:02 -04:00
if (pli_cols_map[i].offset == pli_offsetof(disabled))
{
disabled = sqlite3_column_int64(stmt, i);
*ival = (disabled != 0);
}
else
*ival = sqlite3_column_int(stmt, i);
Add new database code
2009-06-07 12:56:35 -04:00
break;
case DB_TYPE_STRING:
strval = (char **) ((char *)pli + pli_cols_map[i].offset);
cval = (char *)sqlite3_column_text(stmt, i);
if (cval)
*strval = strdup(cval);
break;
default:
DPRINTF(E_LOG, L_DB, "BUG: Unknown type %d in pli column map\n", pli_cols_map[i].type);
sqlite3_finalize(stmt);
free_pli(pli, 0);
return NULL;
}
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_finalize(stmt);
Check that db_pl_fetch_byquery only gets 1 query result
2009-11-22 06:30:29 -05:00
if (ret != SQLITE_DONE)
{
DPRINTF(E_WARN, L_DB, "Query had more than a single result!\n");
free_pli(pli, 0);
return NULL;
}
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
if (pli->type == PL_SPECIAL || pli->type == PL_SMART)
db_files_get_count(&pli->items, &pli->streams, pli->query);
Add new database code
2009-06-07 12:56:35 -04:00
return pli;
}
struct playlist_info *
[library/filescanner/spotify] Add library source abstraction and new "library" thread - Implement filescanner as a library_source - Add library source implementation for spotify - Move process_media_info to library with small adjustments: - Remove dependency to F_SCAN_TYPE defines - Pass data_kind as parameter - Pass media_kind and compilation as parameter if a source forces a specific value for these - Move declaration of scan_ffmpeg to library; add library_add_playlist_info to library
2016-12-31 01:28:18 -05:00
db_pl_fetch_bypath(const char *path)
Add new database code
2009-06-07 12:56:35 -04:00
{
struct playlist_info *pli;
char *query;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = sqlite3_mprintf(Q_PL_SELECT " WHERE f.path = '%q' GROUP BY f.id;", path);
Add db_pl_fetch_bytitlepath
2009-11-22 06:34:37 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
pli = db_pl_fetch_byquery(query);
sqlite3_free(query);
return pli;
}
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
struct playlist_info *
[db] Use db_get_one_int in db_pl_id_bypath
2017-05-01 07:28:46 -04:00
db_pl_fetch_byvirtualpath(const char *virtual_path)
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
{
struct playlist_info *pli;
char *query;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = sqlite3_mprintf(Q_PL_SELECT " WHERE f.virtual_path = '%q' GROUP BY f.id;", virtual_path);
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
pli = db_pl_fetch_byquery(query);
sqlite3_free(query);
return pli;
}
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
struct playlist_info *
db_pl_fetch_byid(int id)
{
struct playlist_info *pli;
char *query;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = sqlite3_mprintf(Q_PL_SELECT " WHERE f.id = %d GROUP BY f.id;", id);
Add support for smart playlists and some default ones Add system playlists for Music, Movies, TV Shows, equivalent to iTunes.
2010-01-21 11:52:51 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
pli = db_pl_fetch_byquery(query);
sqlite3_free(query);
return pli;
}
Add db_pl_fetch_bytitlepath
2009-11-22 06:34:37 -05:00
struct playlist_info *
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_pl_fetch_bytitlepath(const char *title, const char *path)
Add db_pl_fetch_bytitlepath
2009-11-22 06:34:37 -05:00
{
struct playlist_info *pli;
char *query;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
query = sqlite3_mprintf(Q_PL_SELECT " WHERE f.title = '%q' AND f.path = '%q' GROUP BY f.id;", title, path);
Add new database code
2009-06-07 12:56:35 -04:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return NULL;
}
pli = db_pl_fetch_byquery(query);
sqlite3_free(query);
return pli;
}
int
Change db_pl_add/db_pl_update so input is playlist struct - so they work like db_file_add/update and can accept all the struct data (incl. parent_id)
2015-03-14 17:34:03 -04:00
db_pl_add(struct playlist_info *pli, int *id)
Add new database code
2009-06-07 12:56:35 -04:00
{
int ret;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
// If the backend sets 1 it must be preserved, because the backend is still
// scanning and is going to update it later (see filescanner_playlist.c)
if (pli->db_timestamp != 1)
pli->db_timestamp = (uint64_t)time(NULL);
[db] Generic fixup + align fixing up between mfi, pli and queue_item The idea here is to make sure the fixing up of tags is done in a consistent manner. For strings, this means stuff like trimming and empty strings -> null are applied the same unless there are special exception rules set. It also means that defaults are applied the same across structs, e.g. "Unknown artist" for both mfi->artist and queue_item->artist. The change is also necessary because we want to remove trimming from the sql query and instead implement it ourselves.
2018-12-28 13:10:17 -05:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
fixup_tags_pli(pli);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = bind_pli(db_statements.playlists_insert, pli);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = db_statement_run(db_statements.playlists_insert);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (id)
Add new database code
2009-06-07 12:56:35 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = db_pl_id_bypath(pli->path);
if (ret < 0)
return -1;
Change db_pl_add/db_pl_update so input is playlist struct - so they work like db_file_add/update and can accept all the struct data (incl. parent_id)
2015-03-14 17:34:03 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
*id = ret;
Add new database code
2009-06-07 12:56:35 -04:00
}
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
DPRINTF(E_DBG, L_DB, "Added playlist %s (path %s)\n", pli->title, pli->path);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return 0;
}
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
int
db_pl_update(struct playlist_info *pli)
{
int ret;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
// If the backend sets 1 it must be preserved, because the backend is still
// scanning and is going to update it later (see filescanner_playlist.c)
if (pli->db_timestamp != 1)
pli->db_timestamp = (uint64_t)time(NULL);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
fixup_tags_pli(pli);
ret = bind_pli(db_statements.playlists_update, pli);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = db_statement_run(db_statements.playlists_update);
if (ret < 0)
return -1;
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
int
[library/filescanner/spotify] Add library source abstraction and new "library" thread - Implement filescanner as a library_source - Add library source implementation for spotify - Move process_media_info to library with small adjustments: - Remove dependency to F_SCAN_TYPE defines - Pass data_kind as parameter - Pass media_kind and compilation as parameter if a source forces a specific value for these - Move declaration of scan_ffmpeg to library; add library_add_playlist_info to library
2016-12-31 01:28:18 -05:00
db_pl_add_item_bypath(int plid, const char *path)
Add new database code
2009-06-07 12:56:35 -04:00
{
Store playlist items paths instead of resolving to file ids This allows for more dynamic playlists now that files can move around while we're running.
2009-06-11 14:27:31 -04:00
#define Q_TMPL "INSERT INTO playlistitems (playlistid, filepath) VALUES (%d, '%q');"
Add new database code
2009-06-07 12:56:35 -04:00
char *query;
Store playlist items paths instead of resolving to file ids This allows for more dynamic playlists now that files can move around while we're running.
2009-06-11 14:27:31 -04:00
query = sqlite3_mprintf(Q_TMPL, plid, path);
Introduce db_pl_add_item_byid()
2009-11-22 06:17:28 -05:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Introduce db_pl_add_item_byid()
2009-11-22 06:17:28 -05:00
#undef Q_TMPL
}
int
db_pl_add_item_byid(int plid, int fileid)
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "INSERT INTO playlistitems (playlistid, filepath) VALUES (%d, (SELECT f.path FROM files f WHERE f.id = %d));"
Introduce db_pl_add_item_byid()
2009-11-22 06:17:28 -05:00
char *query;
query = sqlite3_mprintf(Q_TMPL, plid, fileid);
Add new database code
2009-06-07 12:56:35 -04:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Store playlist items paths instead of resolving to file ids This allows for more dynamic playlists now that files can move around while we're running.
2009-06-11 14:27:31 -04:00
#undef Q_TMPL
Add new database code
2009-06-07 12:56:35 -04:00
}
Always rescan and update playlists This is needed to keep relative playlist items up to date in the database when the playlist file moves around.
2009-06-11 13:04:21 -04:00
void
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
db_pl_clear_items(int id)
{
#define Q_TMPL "DELETE FROM playlistitems WHERE playlistid = %d;"
char *query;
query = sqlite3_mprintf(Q_TMPL, id);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
#undef Q_TMPL
}
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
Add new database code
2009-06-07 12:56:35 -04:00
void
db_pl_delete(int id)
{
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
#define Q_TMPL "DELETE FROM playlists WHERE id = %d;"
char *query;
Add new database code
2009-06-07 12:56:35 -04:00
int ret;
if (id == 1)
return;
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
query = sqlite3_mprintf(Q_TMPL, id);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
ret = db_query_run(query, 1, 0);
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
if (ret == 0)
db_pl_clear_items(id);
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
#undef Q_TMPL
}
void
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_pl_delete_bypath(const char *path)
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
{
[scan] Fix bugs related to iTunes XML playlists 1) They would get disabled after rescan 2) Playlists and playlistitems didn't get cleaned up
2018-01-25 16:26:00 -05:00
int i;
int ret;
char *query;
char *queries_tmpl[] =
{
"DELETE FROM playlistitems WHERE playlistid IN (SELECT id FROM playlists WHERE path = '%q');",
"DELETE FROM playlists WHERE path = '%q';",
};
Add file and playlist deletion (by path) routines
2009-06-10 15:36:43 -04:00
[scan] Fix bugs related to iTunes XML playlists 1) They would get disabled after rescan 2) Playlists and playlistitems didn't get cleaned up
2018-01-25 16:26:00 -05:00
for (i = 0; i < (sizeof(queries_tmpl) / sizeof(queries_tmpl[0])); i++)
{
query = sqlite3_mprintf(queries_tmpl[i], path);
Add new database code
2009-06-07 12:56:35 -04:00
[scan] Fix bugs related to iTunes XML playlists 1) They would get disabled after rescan 2) Playlists and playlistitems didn't get cleaned up
2018-01-25 16:26:00 -05:00
ret = db_query_run(query, 1, 0);
if (ret == 0)
DPRINTF(E_DBG, L_DB, "Purged %d rows\n", sqlite3_changes(hdl));
}
Add new database code
2009-06-07 12:56:35 -04:00
}
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_pl_disable_bypath(const char *path, enum strip_type strip, uint32_t cookie)
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
{
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#define Q_TMPL "UPDATE playlists SET path = substr(path, %d), virtual_path = substr(virtual_path, %d), disabled = %" PRIi64 " WHERE path = '%q';"
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
int vpath_striplen;
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
vpath_striplen = (strip == STRIP_PATH) ? strlen("/file:") + path_striplen : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, vpath_striplen + 1, disabled, path);
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
#undef Q_TMPL
}
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_pl_disable_bymatch(const char *path, enum strip_type strip, uint32_t cookie)
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
{
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#define Q_TMPL "UPDATE playlists SET path = substr(path, %d), virtual_path = substr(virtual_path, %d), disabled = %" PRIi64 " WHERE path LIKE '%q/%%';"
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
int vpath_striplen;
Add file and playlist disable-by-match routines
2009-06-11 08:42:55 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
vpath_striplen = (strip == STRIP_PATH) ? strlen("/file:") + path_striplen : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, vpath_striplen + 1, disabled, path);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
#undef Q_TMPL
}
int
[db] Add new method db_file_ping_bypath() + cleanup malloc->calloc and char->const char
2017-09-30 18:43:24 -04:00
db_pl_enable_bycookie(uint32_t cookie, const char *path)
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
{
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
#define Q_TMPL "UPDATE playlists SET path = ('%q' || path), virtual_path = ('/file:%q' || virtual_path), disabled = 0 WHERE disabled = %" PRIi64 ";"
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
char *query;
int ret;
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
query = sqlite3_mprintf(Q_TMPL, path, path, (int64_t)cookie);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
ret = db_query_run(query, 1, 0);
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
Add file and playlist enable/disable routines
2009-06-10 16:11:24 -04:00
#undef Q_TMPL
}
Add new database code
2009-06-07 12:56:35 -04:00
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
Make album groups persistent Store groups (only album groups supported at the moment) in the DB, so their ids are persistent for the duration of the forked-daapd session. Those ids are used to, among other things, retrieve artwork, so we must provide ourselves some persistence here. This brings us to schema version 8.
2010-03-06 12:56:30 -05:00
/* Groups */
[db] Review of cache regeneration triggers
2016-12-18 15:18:15 -05:00
// Remove album and artist entries in the groups table that are not longer referenced from the files table
[db] Add function to cleanup the 'groups' table (artists and albums) Allows removing of item no longer referenced from the files table
2016-12-14 13:28:27 -05:00
int
db_groups_cleanup()
{
#define Q_TMPL_ALBUM "DELETE FROM groups WHERE type = 1 AND NOT persistentid IN (SELECT songalbumid from files WHERE disabled = 0);"
#define Q_TMPL_ARTIST "DELETE FROM groups WHERE type = 2 AND NOT persistentid IN (SELECT songartistid from files WHERE disabled = 0);"
int ret;
db_transaction_begin();
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(Q_TMPL_ALBUM, 0, LISTENER_DATABASE);
[db] Add function to cleanup the 'groups' table (artists and albums) Allows removing of item no longer referenced from the files table
2016-12-14 13:28:27 -05:00
if (ret < 0)
{
db_transaction_rollback();
return -1;
}
DPRINTF(E_DBG, L_DB, "Removed album group-entries: %d\n", sqlite3_changes(hdl));
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(Q_TMPL_ARTIST, 0, LISTENER_DATABASE);
[db] Add function to cleanup the 'groups' table (artists and albums) Allows removing of item no longer referenced from the files table
2016-12-14 13:28:27 -05:00
if (ret < 0)
{
db_transaction_rollback();
return -1;
}
DPRINTF(E_DBG, L_DB, "Removed artist group-entries: %d\n", sqlite3_changes(hdl));
db_transaction_end();
return 0;
#undef Q_TMPL_ALBUM
#undef Q_TMPL_ARTIST
}
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
static enum group_type
db_group_type_bypersistentid(int64_t persistentid)
Add groups queries
2010-03-07 06:53:23 -05:00
{
Revert "Merge branch 'db' of git://github.com/chme/forked-daapd into chme-db" This reverts commit b8d5e32160eb360c7f381a46ae696a1f78e91f52, reversing changes made to 5a02f926e3629e9d8fb9b25cb1d90b25d9f89057.
2015-01-08 16:40:47 -05:00
#define Q_TMPL "SELECT g.type FROM groups g WHERE g.persistentid = %" PRIi64 ";"
Add groups queries
2010-03-07 06:53:23 -05:00
char *query;
sqlite3_stmt *stmt;
int ret;
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
query = sqlite3_mprintf(Q_TMPL, persistentid);
Add groups queries
2010-03-07 06:53:23 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, strlen(query) + 1, &stmt, NULL);
Add groups queries
2010-03-07 06:53:23 -05:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add groups queries
2010-03-07 06:53:23 -05:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
Setting log level to info gave a lot of meaningless db.c messages
2014-06-01 17:58:44 -04:00
DPRINTF(E_DBG, L_DB, "No results\n");
Add groups queries
2010-03-07 06:53:23 -05:00
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
}
ret = sqlite3_column_int(stmt, 0);
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add groups queries
2010-03-07 06:53:23 -05:00
sqlite3_finalize(stmt);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
Make album groups persistent Store groups (only album groups supported at the moment) in the DB, so their ids are persistent for the duration of the forked-daapd session. Those ids are used to, among other things, retrieve artwork, so we must provide ourselves some persistence here. This brings us to schema version 8.
2010-03-06 12:56:30 -05:00
Revert "Merge branch 'db' of git://github.com/chme/forked-daapd into chme-db" This reverts commit b8d5e32160eb360c7f381a46ae696a1f78e91f52, reversing changes made to 5a02f926e3629e9d8fb9b25cb1d90b25d9f89057.
2015-01-08 16:40:47 -05:00
int
db_group_persistentid_byid(int id, int64_t *persistentid)
{
#define Q_TMPL "SELECT g.persistentid FROM groups g WHERE g.id = %d;"
char *query;
sqlite3_stmt *stmt;
int ret;
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
DPRINTF(E_DBG, L_DB, "No results\n");
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
*persistentid = sqlite3_column_int64(stmt, 0);
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
#undef Q_TMPL
}
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
/* Directories */
int
[db] Fetch directory id by path; use const for path and virtual_path
2018-11-24 06:14:41 -05:00
db_directory_id_byvirtualpath(const char *virtual_path)
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
{
#define Q_TMPL "SELECT d.id FROM directories d WHERE d.virtual_path = '%q';"
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, virtual_path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
[db] Fetch directory id by path; use const for path and virtual_path
2018-11-24 06:14:41 -05:00
int
db_directory_id_bypath(const char *path)
{
#define Q_TMPL "SELECT d.id FROM directories d WHERE d.path = '%q';"
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
ret = db_file_id_byquery(query);
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
int
db_directory_enum_start(struct directory_enum *de)
{
[db,jsonapi] case insensitive directory/file listing (#784) * [db,jsonapi] case insensitive directory/file listing * [jsonapi] file listing of playlist uses same VPATH ordering as per directory and files * [db,jsonapi] sorting via existing S_VPATH * [db] replace LOWER with COLLATE NOCASE
2019-08-21 16:54:34 -04:00
#define Q_TMPL "SELECT * FROM directories WHERE disabled = 0 AND parent_id = %d ORDER BY virtual_path COLLATE NOCASE;"
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
sqlite3_stmt *stmt;
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
char *query;
int ret;
de->stmt = NULL;
query = sqlite3_mprintf(Q_TMPL, de->parent_id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Starting enum '%s'\n", query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
de->stmt = stmt;
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
return 0;
#undef Q_TMPL
}
int
db_directory_enum_fetch(struct directory_enum *de, struct directory_info *di)
{
uint64_t disabled;
int ret;
memset(di, 0, sizeof(struct directory_info));
if (!de->stmt)
{
DPRINTF(E_LOG, L_DB, "Directory enum not started!\n");
return -1;
}
ret = db_blocking_step(de->stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of directory enum results\n");
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
di->id = sqlite3_column_int(de->stmt, 0);
di->virtual_path = (char *)sqlite3_column_text(de->stmt, 1);
di->db_timestamp = sqlite3_column_int(de->stmt, 2);
disabled = sqlite3_column_int64(de->stmt, 3);
di->disabled = (disabled != 0);
di->parent_id = sqlite3_column_int(de->stmt, 4);
[db] Minor version upgrade: new column "path" in directories table
2018-11-24 03:23:32 -05:00
di->path = (char *)sqlite3_column_text(de->stmt, 5);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
return 0;
}
void
db_directory_enum_end(struct directory_enum *de)
{
if (!de->stmt)
return;
sqlite3_finalize(de->stmt);
de->stmt = NULL;
}
static int
db_directory_add(struct directory_info *di, int *id)
{
[db] Minor version upgrade: new column "path" in directories table
2018-11-24 03:23:32 -05:00
#define QADD_TMPL "INSERT INTO directories (virtual_path, db_timestamp, disabled, parent_id, path)" \
" VALUES (TRIM(%Q), %d, %d, %d, TRIM(%Q));"
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
char *query;
char *errmsg;
[db] Report directory names that end in spaces
2017-11-12 22:40:12 -05:00
int vp_len = strlen(di->virtual_path);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
int ret;
[db] Report directory names that end in spaces
2017-11-12 22:40:12 -05:00
if (vp_len && di->virtual_path[vp_len-1] == ' ')
{
/* Since sqlite removes the trailing space, so these
* directories will be found as new in perpetuity.
*/
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
DPRINTF(E_LOG, L_DB, "Directory name ends with space: '%s'\n", di->virtual_path);
[db] Report directory names that end in spaces
2017-11-12 22:40:12 -05:00
}
[db] Minor version upgrade: new column "path" in directories table
2018-11-24 03:23:32 -05:00
query = sqlite3_mprintf(QADD_TMPL, di->virtual_path, di->db_timestamp, di->disabled, di->parent_id, di->path);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Query error: %s\n", errmsg);
sqlite3_free(errmsg);
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
*id = (int)sqlite3_last_insert_rowid(hdl);
if (*id == 0)
{
DPRINTF(E_LOG, L_DB, "Successful insert but no last_insert_rowid!\n");
return -1;
}
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
DPRINTF(E_DBG, L_DB, "Added directory '%s' with id %d\n", di->virtual_path, *id);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
return 0;
#undef QADD_TMPL
}
static int
db_directory_update(struct directory_info *di)
{
[db] Minor version upgrade: new column "path" in directories table
2018-11-24 03:23:32 -05:00
#define QADD_TMPL "UPDATE directories SET virtual_path = TRIM(%Q), db_timestamp = %d, disabled = %d, parent_id = %d, path = TRIM(%Q)" \
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
" WHERE id = %d;"
char *query;
char *errmsg;
int ret;
/* Add */
[db] Minor version upgrade: new column "path" in directories table
2018-11-24 03:23:32 -05:00
query = sqlite3_mprintf(QADD_TMPL, di->virtual_path, di->db_timestamp, di->disabled, di->parent_id, di->path, di->id);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_exec(query, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Query error: %s\n", errmsg);
sqlite3_free(errmsg);
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
DPRINTF(E_DBG, L_DB, "Updated directory '%s' with id %d\n", di->virtual_path, di->id);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
return 0;
#undef QADD_TMPL
}
int
[db/filescanner/spotify] Set directory path
2018-11-24 03:44:18 -05:00
db_directory_addorupdate(char *virtual_path, char *path, int disabled, int parent_id)
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
{
struct directory_info di;
int id;
int ret;
id = db_directory_id_byvirtualpath(virtual_path);
di.id = id;
di.parent_id = parent_id;
di.virtual_path = virtual_path;
[db/filescanner/spotify] Set directory path
2018-11-24 03:44:18 -05:00
di.path = path;
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
di.disabled = disabled;
di.db_timestamp = (uint64_t)time(NULL);
if (di.id == 0)
ret = db_directory_add(&di, &id);
else
ret = db_directory_update(&di);
if (ret < 0 || id <= 0)
{
DPRINTF(E_LOG, L_DB, "Insert or update of directory failed '%s'\n", virtual_path);
return -1;
}
return id;
}
void
[library/spotify] Implement rescan in spotify.c and purge old files after rescan
2017-01-01 10:51:21 -05:00
db_directory_ping_bymatch(char *virtual_path)
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
{
[library/spotify] Implement rescan in spotify.c and purge old files after rescan
2017-01-01 10:51:21 -05:00
#define Q_TMPL_DIR "UPDATE directories SET db_timestamp = %" PRIi64 " WHERE virtual_path = '%q' OR virtual_path LIKE '%q/%%';"
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
char *query;
[library/spotify] Implement rescan in spotify.c and purge old files after rescan
2017-01-01 10:51:21 -05:00
query = sqlite3_mprintf(Q_TMPL_DIR, (int64_t)time(NULL), virtual_path, virtual_path);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
[db] Review of cache regeneration triggers
2016-12-18 15:18:15 -05:00
db_query_run(query, 1, 0);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#undef Q_TMPL_DIR
}
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_directory_disable_bymatch(char *path, enum strip_type strip, uint32_t cookie)
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
#define Q_TMPL "UPDATE directories SET virtual_path = substr(virtual_path, %d)," \
" disabled = %" PRIi64 " WHERE virtual_path = '/file:%q' OR virtual_path LIKE '/file:%q/%%';"
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int vpath_striplen;
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
vpath_striplen = (strip == STRIP_PATH) ? strlen("/file:") + strlen(path) : 0;
query = sqlite3_mprintf(Q_TMPL, vpath_striplen + 1, disabled, path, path, path);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
db_query_run(query, 1, LISTENER_DATABASE);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
#undef Q_TMPL
}
int
db_directory_enable_bycookie(uint32_t cookie, char *path)
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
#define Q_TMPL "UPDATE directories SET virtual_path = ('/file:%q' || virtual_path)," \
" disabled = 0 WHERE disabled = %" PRIi64 ";"
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path, (int64_t)cookie);
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
#undef Q_TMPL
}
[directories/spotify] Init db with disabled spotify-root-directory and enable only on successful login to spotify
2016-01-30 01:27:20 -05:00
int
db_directory_enable_bypath(char *path)
{
[db] Do not trigger a DATABASE event if db_directory_enable_bypath does not change the library
2017-12-17 03:13:09 -05:00
#define Q_TMPL "UPDATE directories SET disabled = 0 WHERE virtual_path = %Q AND disabled <> 0;"
[directories/spotify] Init db with disabled spotify-root-directory and enable only on successful login to spotify
2016-01-30 01:27:20 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, path);
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
[directories/spotify] Init db with disabled spotify-root-directory and enable only on successful login to spotify
2016-01-30 01:27:20 -05:00
return ((ret < 0) ? -1 : sqlite3_changes(hdl));
#undef Q_TMPL
}
[db/filescanner/spotify] Replace filelist-view with separate directories-table to increase the performance of the mpd command 'lsinfo'
2015-12-27 01:16:50 -05:00
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
/* Remotes */
static int
db_pairing_delete_byremote(char *remote_id)
{
#define Q_TMPL "DELETE FROM pairings WHERE remote = '%q';"
char *query;
query = sqlite3_mprintf(Q_TMPL, remote_id);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
#undef Q_TMPL
}
int
db_pairing_add(struct pairing_info *pi)
{
#define Q_TMPL "INSERT INTO pairings (remote, name, guid) VALUES ('%q', '%q', '%q');"
char *query;
int ret;
ret = db_pairing_delete_byremote(pi->remote_id);
if (ret < 0)
return ret;
query = sqlite3_mprintf(Q_TMPL, pi->remote_id, pi->name, pi->guid);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
#undef Q_TMPL
}
int
db_pairing_fetch_byguid(struct pairing_info *pi)
{
Use table aliases in all queries, update RSP & DAAP filters to match
2011-03-28 13:06:48 -04:00
#define Q_TMPL "SELECT p.* FROM pairings p WHERE p.guid = '%q';"
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
char *query;
sqlite3_stmt *stmt;
int ret;
query = sqlite3_mprintf(Q_TMPL, pi->guid);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(stmt);
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
DPRINTF(E_INFO, L_DB, "Pairing GUID %s not found\n", pi->guid);
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
pi->remote_id = strdup((char *)sqlite3_column_text(stmt, 0));
pi->name = strdup((char *)sqlite3_column_text(stmt, 1));
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
#undef Q_TMPL
}
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
#ifdef HAVE_SPOTIFY_H
/* Spotify */
void
db_spotify_purge(void)
{
[db] Only trigger the library update callback, if a query changed at least one row
2017-11-12 04:46:05 -05:00
#define Q_TMPL "UPDATE directories SET disabled = %" PRIi64 " WHERE virtual_path = '/spotify:' AND disabled <> %" PRIi64 ";"
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
char *queries[4] =
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
{
"DELETE FROM files WHERE path LIKE 'spotify:%%';",
"DELETE FROM playlistitems WHERE filepath LIKE 'spotify:%%';",
"DELETE FROM playlists WHERE path LIKE 'spotify:%%';",
[directories/spotify] Init db with disabled spotify-root-directory and enable only on successful login to spotify
2016-01-30 01:27:20 -05:00
"DELETE FROM directories WHERE virtual_path LIKE '/spotify:/%%';",
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
};
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
char *query;
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
int i;
int ret;
for (i = 0; i < (sizeof(queries) / sizeof(queries[0])); i++)
{
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(queries[i], 0, LISTENER_DATABASE);
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
if (ret == 0)
[spotify] Keep saved tracks through restarts + misc fixing up
2016-11-13 14:28:29 -05:00
DPRINTF(E_DBG, L_DB, "Processed %d rows\n", sqlite3_changes(hdl));
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
}
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
// Disable the spotify directory by setting 'disabled' to INOTIFY_FAKE_COOKIE value
[db] Only trigger the library update callback, if a query changed at least one row
2017-11-12 04:46:05 -05:00
query = sqlite3_mprintf(Q_TMPL, INOTIFY_FAKE_COOKIE, INOTIFY_FAKE_COOKIE);
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return;
}
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
[db] Small code improvements (avoid hard coded values in query strings)
2016-11-12 06:35:22 -05:00
if (ret == 0)
DPRINTF(E_DBG, L_DB, "Disabled spotify directory\n");
#undef Q_TMPL
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
}
/* Spotify */
void
db_spotify_pl_delete(int id)
{
[spotify/artwork] Remove spotify songs after playlist update and delete cached artwork for removed spotify songs
2016-01-16 11:02:03 -05:00
char *queries_tmpl[2] =
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
{
"DELETE FROM playlists WHERE id = %d;",
"DELETE FROM playlistitems WHERE playlistid = %d;",
};
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
char *query;
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
int i;
int ret;
for (i = 0; i < (sizeof(queries_tmpl) / sizeof(queries_tmpl[0])); i++)
{
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
query = sqlite3_mprintf(queries_tmpl[i], id);
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
Add db_query_run() to get rid of some redundancy in db.c
2014-08-17 18:20:23 -04:00
if (ret == 0)
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
DPRINTF(E_DBG, L_DB, "Deleted %d rows\n", sqlite3_changes(hdl));
}
}
[spotify/artwork] Remove spotify songs after playlist update and delete cached artwork for removed spotify songs
2016-01-16 11:02:03 -05:00
/* Spotify */
void
[spotify] Keep saved tracks through restarts + misc fixing up
2016-11-13 14:28:29 -05:00
db_spotify_files_delete(void)
[spotify/artwork] Remove spotify songs after playlist update and delete cached artwork for removed spotify songs
2016-01-16 11:02:03 -05:00
{
#define Q_TMPL "DELETE FROM files WHERE path LIKE 'spotify:%%' AND NOT path IN (SELECT filepath FROM playlistitems);"
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL);
Rework user rating updates
2017-12-09 11:12:13 -05:00
ret = db_query_run(query, 1, LISTENER_DATABASE);
[spotify/artwork] Remove spotify songs after playlist update and delete cached artwork for removed spotify songs
2016-01-16 11:02:03 -05:00
if (ret == 0)
DPRINTF(E_DBG, L_DB, "Deleted %d rows\n", sqlite3_changes(hdl));
#undef Q_TMPL
}
Add support for Spotify (squashed commit), and: - Try to not return items which a client can't play - Remove inotify subscription to IN_MODIFY and IN_CREATE - Fix crash on unknown codec type in transcode.c - Probably added some new bugs...
2014-03-11 18:20:29 -04:00
#endif
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
/* Admin */
int
[db] Remove db_admin_update and rename db_admin_add
2016-12-09 10:31:42 -05:00
db_admin_set(const char *key, const char *value)
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
{
Avoid duplicate rows in the admin table
2014-08-27 16:12:42 -04:00
#define Q_TMPL "INSERT OR REPLACE INTO admin (key, value) VALUES ('%q', '%q');"
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
char *query;
query = sqlite3_mprintf(Q_TMPL, key, value);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
#undef Q_TMPL
}
[db] Functions to read/store int in the admin table and introduce constants for admin table keys
2017-11-19 01:46:28 -05:00
int
db_admin_setint(const char *key, int value)
{
#define Q_TMPL "INSERT OR REPLACE INTO admin (key, value) VALUES ('%q', '%d');"
char *query;
query = sqlite3_mprintf(Q_TMPL, key, value);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
int
db_admin_setint64(const char *key, int64_t value)
{
#define Q_TMPL "INSERT OR REPLACE INTO admin (key, value) VALUES ('%q', '%" PRIi64 "');"
char *query;
query = sqlite3_mprintf(Q_TMPL, key, value);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
static int
admin_get(const char *key, short type, void *value)
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
{
#define Q_TMPL "SELECT value FROM admin a WHERE a.key = '%q';"
char *query;
sqlite3_stmt *stmt;
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
char *cval;
int32_t *ival;
int64_t *i64val;
char **strval;
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
int ret;
query = sqlite3_mprintf(Q_TMPL, key);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return -1;
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, strlen(query) + 1, &stmt, NULL);
if (ret != SQLITE_OK)
{
[db] Silence misleading log error message We were logging a missing lastfm_sk in the admin table as an error, which it really isn't
2018-03-03 14:13:09 -05:00
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
sqlite3_free(query);
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return -1;
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
DPRINTF(E_DBG, L_DB, "No results\n");
else
[db] Silence misleading log error message We were logging a missing lastfm_sk in the admin table as an error, which it really isn't
2018-03-03 14:13:09 -05:00
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
sqlite3_finalize(stmt);
sqlite3_free(query);
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return -1;
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
}
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
switch (type)
{
case DB_TYPE_INT:
ival = (int32_t *) value;
*ival = sqlite3_column_int(stmt, 0);
break;
case DB_TYPE_INT64:
i64val = (int64_t *) value;
*i64val = sqlite3_column_int64(stmt, 0);
break;
case DB_TYPE_STRING:
strval = (char **) value;
cval = (char *)sqlite3_column_text(stmt, 0);
if (cval)
*strval = strdup(cval);
break;
default:
DPRINTF(E_LOG, L_DB, "BUG: Unknown type %d in admin_set\n", type);
ret = -2;
}
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
sqlite3_finalize(stmt);
sqlite3_free(query);
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return ret;
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
#undef Q_TMPL
}
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
char *
db_admin_get(const char *key)
{
char *value = NULL;
int ret;
ret = admin_get(key, DB_TYPE_STRING, &value);
if (ret < 0)
{
[db] Silence misleading log error message We were logging a missing lastfm_sk in the admin table as an error, which it really isn't
2018-03-03 14:13:09 -05:00
DPRINTF(E_DBG, L_DB, "Could not find key '%s' in admin table\n", key);
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return NULL;
}
return value;
}
[db] Functions to read/store int in the admin table and introduce constants for admin table keys
2017-11-19 01:46:28 -05:00
int
db_admin_getint(const char *key)
{
int value = 0;
int ret;
ret = admin_get(key, DB_TYPE_INT, &value);
if (ret < 0)
{
[db] Silence misleading log error message We were logging a missing lastfm_sk in the admin table as an error, which it really isn't
2018-03-03 14:13:09 -05:00
DPRINTF(E_DBG, L_DB, "Could not find key '%s' in admin table\n", key);
[db] Functions to read/store int in the admin table and introduce constants for admin table keys
2017-11-19 01:46:28 -05:00
return 0;
}
return value;
}
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
int64_t
db_admin_getint64(const char *key)
{
int64_t value = 0;
int ret;
ret = admin_get(key, DB_TYPE_INT64, &value);
if (ret < 0)
{
[db] Silence misleading log error message We were logging a missing lastfm_sk in the admin table as an error, which it really isn't
2018-03-03 14:13:09 -05:00
DPRINTF(E_DBG, L_DB, "Could not find key '%s' in admin table\n", key);
[db] Add functions to read/store int64 values in admin table
2017-11-12 03:27:26 -05:00
return 0;
}
return value;
}
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
int
db_admin_delete(const char *key)
{
#define Q_TMPL "DELETE FROM admin where key='%q';"
char *query;
query = sqlite3_mprintf(Q_TMPL, key);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Add db interface to update the admin table
2014-08-15 16:54:47 -04:00
#undef Q_TMPL
}
Add Remote pairing info storage facility This brings schema_version to 6.
2010-01-30 11:01:27 -05:00
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
/* Speakers */
int
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
db_speaker_save(struct output_device *device)
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
{
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
#define Q_TMPL "INSERT OR REPLACE INTO speakers (id, selected, volume, name, auth_key) VALUES (%" PRIi64 ", %d, %d, %Q, %Q);"
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
char *query;
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
query = sqlite3_mprintf(Q_TMPL, device->id, device->selected, device->volume, device->name, device->auth_key);
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
return db_query_run(query, 1, 0);
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
#undef Q_TMPL
}
int
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
db_speaker_get(struct output_device *device, uint64_t id)
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
{
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
#define Q_TMPL "SELECT s.selected, s.volume, s.name, s.auth_key FROM speakers s WHERE s.id = %" PRIi64 ";"
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
sqlite3_stmt *stmt;
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
ret = -1;
goto out;
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret != SQLITE_DONE)
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
ret = -1;
goto out;
}
[raop] Add support for Apple TV device verification, required by tvOS 10.2 (fix for issue #377) - also change how speakers are saved/retrieved from the db - add generic authorization methods in outputs.c and player.c - let filescanner read *.verification files (containing PIN) - configure options to enable and disable, since libsodium is required
2017-06-19 15:52:01 -04:00
device->id = id;
device->selected = sqlite3_column_int(stmt, 0);
device->volume = sqlite3_column_int(stmt, 1);
free(device->name);
device->name = safe_strdup((char *)sqlite3_column_text(stmt, 2));
free(device->auth_key);
device->auth_key = safe_strdup((char *)sqlite3_column_text(stmt, 3));
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
Queries must hit SQLITE_DONE to execute profiling callback
2011-06-11 11:24:59 -04:00
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
sqlite3_finalize(stmt);
ret = 0;
out:
sqlite3_free(query);
return ret;
#undef Q_TMPL
}
void
db_speaker_clear_all(void)
{
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run("UPDATE speakers SET selected = 0;", 0, 0);
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/* Queue */
Add a dedicated table for speakers
2010-11-02 13:40:14 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/*
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
* Start a new transaction for modifying the queue. Returns the new queue version for the following changes.
* After finishing all queue modifications 'queue_transaction_end' needs to be called.
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
*/
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
static int
queue_transaction_begin()
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
{
[db] Rename "plversion" to "queue_version", add missing init query for queue_version
2016-12-03 01:00:28 -05:00
int queue_version;
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_begin();
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
queue_version = db_admin_getint(DB_ADMIN_QUEUE_VERSION);
[db] Rename "plversion" to "queue_version", add missing init query for queue_version
2016-12-03 01:00:28 -05:00
queue_version++;
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return queue_version;
}
/*
* If retval == 0, updates the version of the queue in the admin table, commits the transaction
* and notifies listener of LISTENER_QUEUE about the changes.
* If retval < 0, rollsback the transaction.
*
* This function must be called after modifying the queue.
*
* @param retval 'retval' == 0, if modifying the queue was successful or 'retval' < 0 if an error occurred
* @param queue_version The new queue version, for the pending modifications
*/
static void
queue_transaction_end(int retval, int queue_version)
{
int ret;
if (retval != 0)
goto error;
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
ret = db_admin_setint(DB_ADMIN_QUEUE_VERSION, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto error;
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
[listener] Rename LISTENER_PLAYLIST to LISTENER_QUEUE
2017-01-07 18:24:40 -05:00
listener_notify(LISTENER_QUEUE);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return;
error:
db_transaction_rollback();
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
static int
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_reshuffle(uint32_t item_id, int queue_version);
static int
queue_add_file(struct db_media_file_info *dbmfi, int pos, int shuffle_pos, int queue_version)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
#define Q_TMPL "INSERT INTO queue " \
"(id, file_id, song_length, data_kind, media_kind, " \
"pos, shuffle_pos, path, virtual_path, title, " \
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
"artist, composer, album_artist, album, genre, songalbumid, songartistid," \
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
"time_modified, artist_sort, album_sort, album_artist_sort, year, " \
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
"type, bitrate, samplerate, channels, " \
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
"track, disc, queue_version)" \
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
"VALUES" \
"(NULL, %s, %s, %s, %s, " \
"%d, %d, %Q, %Q, %Q, " \
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
"%Q, %Q, %Q, %Q, %Q, %s, %s," \
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
"%s, %Q, %Q, %Q, %s, " \
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
"%Q, %s, %s, %s, " \
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
"%s, %s, %d);"
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
char *query;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
query = sqlite3_mprintf(Q_TMPL,
dbmfi->id, dbmfi->song_length, dbmfi->data_kind, dbmfi->media_kind,
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
pos, shuffle_pos, dbmfi->path, dbmfi->virtual_path, dbmfi->title,
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
dbmfi->artist, dbmfi->composer, dbmfi->album_artist, dbmfi->album, dbmfi->genre, dbmfi->songalbumid, dbmfi->songartistid,
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
dbmfi->time_modified, dbmfi->artist_sort, dbmfi->album_sort, dbmfi->album_artist_sort, dbmfi->year,
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
dbmfi->type, dbmfi->bitrate, dbmfi->samplerate, dbmfi->channels,
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
dbmfi->track, dbmfi->disc, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
Add watch deletion by path/match/cookie routines
2009-06-11 10:12:17 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
#undef Q_TMPL
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
static int
queue_add_item(struct db_queue_item *item, int pos, int shuffle_pos, int queue_version)
{
#define Q_TMPL "INSERT INTO queue " \
"(id, file_id, song_length, data_kind, media_kind, " \
"pos, shuffle_pos, path, virtual_path, title, " \
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
"artist, composer, album_artist, album, genre, songalbumid, songartistid, " \
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
"time_modified, artist_sort, album_sort, album_artist_sort, year, " \
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
"type, bitrate, samplerate, channels, " \
[spotify] Set artwork url in queue items for spotify tracks Fixes missing artwork for spotify tracks that are not in the user library.
2018-11-28 14:31:50 -05:00
"track, disc, artwork_url, queue_version)" \
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
"VALUES" \
"(NULL, %d, %d, %d, %d, " \
"%d, %d, %Q, %Q, %Q, " \
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
"%Q, %Q, %Q, %Q, %Q, %" PRIi64 ", %" PRIi64 "," \
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
"%d, %Q, %Q, %Q, %d, " \
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
"%Q, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", " \
[spotify] Set artwork url in queue items for spotify tracks Fixes missing artwork for spotify tracks that are not in the user library.
2018-11-28 14:31:50 -05:00
"%d, %d, %Q, %d);"
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL,
item->file_id, item->song_length, item->data_kind, item->media_kind,
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
pos, shuffle_pos, item->path, item->virtual_path, item->title,
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
item->artist, item->composer, item->album_artist, item->album, item->genre, item->songalbumid, item->songartistid,
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
item->time_modified, item->artist_sort, item->album_sort, item->album_artist_sort, item->year,
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
item->type, item->bitrate, item->samplerate, item->channels,
[spotify] Set artwork url in queue items for spotify tracks Fixes missing artwork for spotify tracks that are not in the user library.
2018-11-28 14:31:50 -05:00
item->track, item->disc, item->artwork_url, queue_version);
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
ret = db_query_run(query, 1, 0);
return ret;
#undef Q_TMPL
}
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
int
db_queue_update_item(struct db_queue_item *qi)
{
#define Q_TMPL "UPDATE queue SET " \
"file_id = %d, song_length = %d, data_kind = %d, media_kind = %d, " \
"pos = %d, shuffle_pos = %d, path = '%q', virtual_path = %Q, " \
"title = %Q, artist = %Q, album_artist = %Q, album = %Q, " \
[db] schema v19.11 support composer in queue tbl
2018-11-21 07:52:13 -05:00
"composer = %Q," \
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
"genre = %Q, time_modified = %d, " \
"songalbumid = %" PRIi64 ", songartistid = %" PRIi64 ", " \
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
"artist_sort = %Q, album_sort = %Q, album_artist_sort = %Q, " \
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
"year = %d, track = %d, disc = %d, artwork_url = %Q, " \
"queue_version = %d " \
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
"WHERE id = %d;"
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
char *query;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
query = sqlite3_mprintf(Q_TMPL,
qi->file_id, qi->song_length, qi->data_kind, qi->media_kind,
qi->pos, qi->shuffle_pos, qi->path, qi->virtual_path,
qi->title, qi->artist, qi->album_artist, qi->album,
[db] schema v19.11 support composer in queue tbl
2018-11-21 07:52:13 -05:00
qi->composer,
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
qi->genre, qi->time_modified,
qi->songalbumid, qi->songartistid,
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
qi->artist_sort, qi->album_sort, qi->album_artist_sort,
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
qi->year, qi->track, qi->disc, qi->artwork_url, queue_version,
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
qi->id);
ret = db_query_run(query, 1, 0);
[db] Queue notification when metadata changes (#448)
2017-12-02 10:44:29 -05:00
/* MPD changes playlist version when metadata changes */
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_transaction_end(ret, queue_version);
[db] Queue notification when metadata changes (#448)
2017-12-02 10:44:29 -05:00
[db] Remove special icy update function, add db_queue_update_item() - we will use the latter generalised form from now on, even though it is perhaps a tad slower
2017-01-22 17:10:15 -05:00
return ret;
#undef Q_TMPL
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/*
* Adds the files matching the given query to the queue after the item with the given item id
*
* The files table is queried with the given parameters and all found files are added after the
* item with the given item id to the "normal" queue. They are appended to end of the shuffled queue
* (assuming that the shuffled queue will get reshuffled after adding new items).
*
* The function returns -1 on failure (e. g. error reading from database) and if the given item id
* does not exist. It wraps all database access in a transaction and performs a rollback if an error
* occurs, leaving the queue in a consistent state.
*
* @param qp Query parameters for the files table
* @param item_id Files are added after item with this id
* @return 0 on success, -1 on failure
*/
int
db_queue_add_by_queryafteritemid(struct query_params *qp, uint32_t item_id)
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
{
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int pos;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
int ret;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Position of the first new item
pos = db_queue_get_pos(item_id, 0);
if (pos < 0)
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
{
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
return -1;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
pos++;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
ret = db_queue_add_by_query(qp, 0, 0, pos, NULL, NULL);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return ret;
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
int
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
db_queue_add_start(struct db_queue_add_info *queue_add_info, int pos)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
uint32_t queue_count;
int ret;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
memset(queue_add_info, 0, sizeof(struct db_queue_add_info));
queue_add_info->queue_version = queue_transaction_begin();
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
ret = db_queue_get_count(&queue_count);
if (ret < 0)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
ret = -1;
queue_transaction_end(ret, queue_add_info->queue_version);
return ret;
}
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
queue_add_info->pos = queue_count;
queue_add_info->shuffle_pos = queue_count;
if (pos >= 0 && pos < queue_count)
queue_add_info->pos = pos;
queue_add_info->start_pos = queue_add_info->pos;
return 0;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
int
[library/db/filescanner/spotify] Reshuffle after adding non library items to the queue
2018-11-10 01:41:36 -05:00
db_queue_add_end(struct db_queue_add_info *queue_add_info, char reshuffle, uint32_t item_id, int ret)
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
{
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
char *query;
// Update pos for all items from the given position
if (ret == 0)
{
query = sqlite3_mprintf("UPDATE queue SET pos = pos + %d, queue_version = %d WHERE pos >= %d AND queue_version < %d;",
queue_add_info->count, queue_add_info->queue_version, queue_add_info->start_pos, queue_add_info->queue_version);
ret = db_query_run(query, 1, 0);
}
[library/db/filescanner/spotify] Reshuffle after adding non library items to the queue
2018-11-10 01:41:36 -05:00
// Reshuffle after adding new items
if (ret == 0 && reshuffle)
{
ret = queue_reshuffle(item_id, queue_add_info->queue_version);
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
queue_transaction_end(ret, queue_add_info->queue_version);
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
return ret;
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
}
int
db_queue_add_item(struct db_queue_add_info *queue_add_info, struct db_queue_item *item)
{
int ret;
fixup_tags_queue_item(item);
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
ret = queue_add_item(item, queue_add_info->pos, queue_add_info->shuffle_pos, queue_add_info->queue_version);
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
if (ret == 0)
[db/queue] Support adding non-library items at a given position to the queue
2018-10-13 02:30:41 -04:00
{
queue_add_info->pos++;
queue_add_info->shuffle_pos++;
queue_add_info->count++;
if (queue_add_info->new_item_id == 0)
queue_add_info->new_item_id = (int) sqlite3_last_insert_rowid(hdl);
}
Refactor adding non library items to the queue Instead of asking a client to first scan the path into a media_file_info object and afterwards add it to the queue, we now offer a library function to directly add a path. The library-source that can handle the given path translates the path into new queue item(s) and adds them to the queue.
2018-03-09 13:03:43 -05:00
return ret;
#undef Q_TMPL
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/*
* Adds the files matching the given query to the queue
*
* The files table is queried with the given parameters and all found files are added to the end of the
* "normal" queue and the shuffled queue.
*
* The function returns -1 on failure (e. g. error reading from database). It wraps all database access
* in a transaction and performs a rollback if an error occurs, leaving the queue in a consistent state.
*
* @param qp Query parameters for the files table
* @param reshuffle If 1 queue will be reshuffled after adding new items
* @param item_id The base item id, all items after this will be reshuffled
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
* @param position The position in the queue for the new queue item, -1 to add at end of queue
* @param count If not NULL returns the number of items added to the queue
* @param new_item_id If not NULL return the queue item id of the first new queue item
* @return 0 on success, -1 on failure
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
*/
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
int
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
db_queue_add_by_query(struct query_params *qp, char reshuffle, uint32_t item_id, int position, int *count, int *new_item_id)
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
{
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_media_file_info dbmfi;
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
char *query;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
uint32_t queue_count;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int pos;
int ret;
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
if (new_item_id)
*new_item_id = 0;
if (count)
*count = 0;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
ret = db_queue_get_count(&queue_count);
if (ret < 0)
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = -1;
goto end_transaction;
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_start(qp);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
DPRINTF(E_DBG, L_DB, "Player queue query returned %d items\n", qp->results);
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
[db] Do not notify clients in 'db_queue_add_by_query' if no items were added
2017-03-05 02:46:00 -05:00
if (qp->results == 0)
{
db_query_end(qp);
[db] Fix adding urls to the queue that are not in the library
2017-12-13 16:01:19 -05:00
db_transaction_end();
return 0;
[db] Do not notify clients in 'db_queue_add_by_query' if no items were added
2017-03-05 02:46:00 -05:00
}
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
if (position < 0 || position > queue_count)
{
pos = queue_count;
}
else
{
pos = position;
// Update pos for all items from the given position (make room for the new items in the queue)
query = sqlite3_mprintf("UPDATE queue SET pos = pos + %d, queue_version = %d WHERE pos >= %d;", qp->results, queue_version, pos);
ret = db_query_run(query, 1, 0);
if (ret < 0)
goto end_transaction;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
while (((ret = db_query_fetch_file(qp, &dbmfi)) == 0) && (dbmfi.id))
Fix so permission changes in the library are handled (issue #8)
2014-06-09 17:42:02 -04:00
{
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
ret = queue_add_file(&dbmfi, pos, queue_count, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
DPRINTF(E_DBG, L_DB, "Failed to add song id %s (%s)\n", dbmfi.id, dbmfi.title);
break;
}
DPRINTF(E_DBG, L_DB, "Added song id %s (%s) to queue\n", dbmfi.id, dbmfi.title);
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
if (new_item_id && *new_item_id == 0)
*new_item_id = (int) sqlite3_last_insert_rowid(hdl);
if (count)
(*count)++;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
pos++;
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
queue_count++;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
db_query_end(qp);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Reshuffle after adding new items
if (reshuffle)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_reshuffle(item_id, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
return ret;
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/*
* Adds the items of the stored playlist with the given id to the end of the queue
*
* @param plid Id of the stored playlist
* @param reshuffle If 1 queue will be reshuffled after adding new items
* @param item_id The base item id, all items after this will be reshuffled
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
* @param position The position in the queue for the new queue item, -1 to add at end of queue
* @param count If not NULL returns the number of items added to the queue
* @param new_item_id If not NULL return the queue item id of the first new queue item
* @return 0 on success, -1 on failure
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
*/
int
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
db_queue_add_by_playlistid(int plid, char reshuffle, uint32_t item_id, int position, int *count, int *new_item_id)
Add watch-marking routines
2009-06-11 09:24:10 -04:00
{
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct query_params qp;
int ret;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
memset(&qp, 0, sizeof(struct query_params));
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
qp.id = plid;
qp.type = Q_PLITEMS;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
ret = db_queue_add_by_query(&qp, reshuffle, item_id, position, count, new_item_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
/*
* Adds the file with the given id to the queue
*
* @param id Id of the file
* @param reshuffle If 1 queue will be reshuffled after adding new items
* @param item_id The base item id, all items after this will be reshuffled
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
* @param position The position in the queue for the new queue item, -1 to add at end of queue
* @param count If not NULL returns the number of items added to the queue
* @param new_item_id If not NULL return the queue item id of the first new queue item
* @return 0 on success, -1 on failure
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
*/
int
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
db_queue_add_by_fileid(int id, char reshuffle, uint32_t item_id, int position, int *count, int *new_item_id)
Add watch-marking routines
2009-06-11 09:24:10 -04:00
{
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct query_params qp;
char buf[124];
int ret;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
memset(&qp, 0, sizeof(struct query_params));
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
qp.type = Q_ITEMS;
snprintf(buf, sizeof(buf), "f.id = %" PRIu32, id);
qp.filter = buf;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
[db] Add support to add items to the queue at specified position
2018-09-06 15:16:27 -04:00
ret = db_queue_add_by_query(&qp, reshuffle, item_id, position, count, new_item_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
Add watch-marking routines
2009-06-11 09:24:10 -04:00
}
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
static int
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
queue_enum_start(struct query_params *qp)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Improve speed of browse queries (issue #478) Before, we returned either unordered (for RSP, meaning client had to sort) or ordered by a client selected sort_clause[]. The latter are multi-purpose and therefore not optimised for browse queries. To speed up, we predefine the entire set of browse queries, including order, with matching indices. The predefined queries are used except if the client explicitly requests a non-default order or query. As a special bonus, the commit also allows queries with I_SUB that have an offset but no limit.
2018-01-20 18:22:21 -05:00
#define Q_TMPL "SELECT * FROM queue f WHERE %s ORDER BY %s;"
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
sqlite3_stmt *stmt;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
char *query;
[db] Remove db_queue_enum struct and use generic query_params
2016-12-04 02:18:33 -05:00
const char *orderby;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
qp->stmt = NULL;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
if (qp->sort)
orderby = sort_clause[qp->sort];
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
[db] Remove db_queue_enum struct and use generic query_params
2016-12-04 02:18:33 -05:00
orderby = sort_clause[S_POS];
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
if (qp->filter)
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
query = sqlite3_mprintf(Q_TMPL, qp->filter, orderby);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
query = sqlite3_mprintf(Q_TMPL, "1=1", orderby);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Starting enum '%s'\n", query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
qp->stmt = stmt;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return 0;
#undef Q_TMPL
}
static inline char *
strdup_if(char *str, int cond)
{
if (str == NULL)
return NULL;
if (cond)
return strdup(str);
return str;
}
static int
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
queue_enum_fetch(struct query_params *qp, struct db_queue_item *queue_item, int keep_item)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
int ret;
memset(queue_item, 0, sizeof(struct db_queue_item));
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
if (!qp->stmt)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
DPRINTF(E_LOG, L_DB, "Queue enum not started!\n");
return -1;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = db_blocking_step(qp->stmt);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of queue enum results\n");
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
queue_item->id = (uint32_t)sqlite3_column_int(qp->stmt, 0);
queue_item->file_id = (uint32_t)sqlite3_column_int(qp->stmt, 1);
queue_item->pos = (uint32_t)sqlite3_column_int(qp->stmt, 2);
queue_item->shuffle_pos = (uint32_t)sqlite3_column_int(qp->stmt, 3);
queue_item->data_kind = sqlite3_column_int(qp->stmt, 4);
queue_item->media_kind = sqlite3_column_int(qp->stmt, 5);
queue_item->song_length = (uint32_t)sqlite3_column_int(qp->stmt, 6);
queue_item->path = strdup_if((char *)sqlite3_column_text(qp->stmt, 7), keep_item);
queue_item->virtual_path = strdup_if((char *)sqlite3_column_text(qp->stmt, 8), keep_item);
queue_item->title = strdup_if((char *)sqlite3_column_text(qp->stmt, 9), keep_item);
queue_item->artist = strdup_if((char *)sqlite3_column_text(qp->stmt, 10), keep_item);
queue_item->album_artist = strdup_if((char *)sqlite3_column_text(qp->stmt, 11), keep_item);
queue_item->album = strdup_if((char *)sqlite3_column_text(qp->stmt, 12), keep_item);
queue_item->genre = strdup_if((char *)sqlite3_column_text(qp->stmt, 13), keep_item);
queue_item->songalbumid = sqlite3_column_int64(qp->stmt, 14);
queue_item->time_modified = sqlite3_column_int(qp->stmt, 15);
queue_item->artist_sort = strdup_if((char *)sqlite3_column_text(qp->stmt, 16), keep_item);
queue_item->album_sort = strdup_if((char *)sqlite3_column_text(qp->stmt, 17), keep_item);
queue_item->album_artist_sort = strdup_if((char *)sqlite3_column_text(qp->stmt, 18), keep_item);
queue_item->year = sqlite3_column_int(qp->stmt, 19);
queue_item->track = sqlite3_column_int(qp->stmt, 20);
queue_item->disc = sqlite3_column_int(qp->stmt, 21);
queue_item->artwork_url = strdup_if((char *)sqlite3_column_text(qp->stmt, 22), keep_item);
[db] Add missing mapping of queue version into queue item on fetch
2019-10-20 02:38:40 -04:00
queue_item->queue_version = sqlite3_column_int(qp->stmt, 23);
[db] schema v19.11 support composer in queue tbl
2018-11-21 07:52:13 -05:00
queue_item->composer = strdup_if((char *)sqlite3_column_text(qp->stmt, 24), keep_item);
[db] add songartistid to queue tbl
2019-02-01 10:39:10 -05:00
queue_item->songartistid = sqlite3_column_int64(qp->stmt, 25);
[db] schema v20.01 support codec type/bitrate/samplerate in queue tbl
2019-06-04 16:51:44 -04:00
queue_item->type = strdup_if((char *)sqlite3_column_text(qp->stmt, 26), keep_item);
queue_item->bitrate = sqlite3_column_int(qp->stmt, 27);
queue_item->samplerate = sqlite3_column_int(qp->stmt, 28);
[db] add 'channels' to file/queue tbl
2019-06-07 04:53:37 -04:00
queue_item->channels = sqlite3_column_int(qp->stmt, 29);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return 0;
}
int
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_queue_enum_start(struct query_params *qp)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
int ret;
db_transaction_begin();
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
db_transaction_rollback();
return ret;
}
void
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_queue_enum_end(struct query_params *qp)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_query_end(qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
}
int
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_queue_enum_fetch(struct query_params *qp, struct db_queue_item *queue_item)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
return queue_enum_fetch(qp, queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
int
db_queue_get_pos(uint32_t item_id, char shuffle)
{
#define Q_TMPL "SELECT pos FROM queue WHERE id = %d;"
#define Q_TMPL_SHUFFLE "SELECT shuffle_pos FROM queue WHERE id = %d;"
char *query;
int pos;
if (shuffle)
query = sqlite3_mprintf(Q_TMPL_SHUFFLE, item_id);
else
query = sqlite3_mprintf(Q_TMPL, item_id);
[db] Rename db_get_count to db_get_one_int
2016-12-09 10:20:03 -05:00
pos = db_get_one_int(query);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
sqlite3_free(query);
return pos;
#undef Q_TMPL
#undef Q_TMPL_SHUFFLE
}
static int
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
queue_fetch_byitemid(uint32_t item_id, struct db_queue_item *queue_item, int with_metadata)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
struct query_params qp;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
memset(&qp, 0, sizeof(struct query_params));
qp.filter = sqlite3_mprintf("id = %d", item_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(&qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return -1;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_fetch(&qp, queue_item, with_metadata);
db_query_end(&qp);
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
struct db_queue_item *
db_queue_fetch_byitemid(uint32_t item_id)
{
struct db_queue_item *queue_item;
int ret;
queue_item = calloc(1, sizeof(struct db_queue_item));
if (!queue_item)
{
DPRINTF(E_LOG, L_DB, "Out of memory for queue_item\n");
return NULL;
}
db_transaction_begin();
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_byitemid(item_id, queue_item, 1);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
if (ret < 0)
{
free_queue_item(queue_item, 0);
DPRINTF(E_LOG, L_DB, "Error fetching queue item by item id\n");
return NULL;
}
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
else if (queue_item->id == 0)
[player] Fix segfault if player reaches end of queue, fix repeat single
2016-11-12 12:45:54 -05:00
{
// No item found
free_queue_item(queue_item, 0);
return NULL;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return queue_item;
}
struct db_queue_item *
db_queue_fetch_byfileid(uint32_t file_id)
{
struct db_queue_item *queue_item;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
struct query_params qp;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
memset(&qp, 0, sizeof(struct query_params));
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
queue_item = calloc(1, sizeof(struct db_queue_item));
if (!queue_item)
{
DPRINTF(E_LOG, L_DB, "Out of memory for queue_item\n");
return NULL;
}
db_transaction_begin();
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
qp.filter = sqlite3_mprintf("file_id = %d", file_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(&qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
free_queue_item(queue_item, 0);
DPRINTF(E_LOG, L_DB, "Error fetching queue item by file id\n");
return NULL;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_fetch(&qp, queue_item, 1);
db_query_end(&qp);
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
if (ret < 0)
{
free_queue_item(queue_item, 0);
DPRINTF(E_LOG, L_DB, "Error fetching queue item by file id\n");
return NULL;
}
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
else if (queue_item->id == 0)
[player] Fix segfault if player reaches end of queue, fix repeat single
2016-11-12 12:45:54 -05:00
{
// No item found
free_queue_item(queue_item, 0);
return NULL;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return queue_item;
}
static int
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
queue_fetch_bypos(uint32_t pos, char shuffle, struct db_queue_item *queue_item, int with_metadata)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
struct query_params qp;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
memset(&qp, 0, sizeof(struct query_params));
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (shuffle)
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
qp.filter = sqlite3_mprintf("shuffle_pos = %d", pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
qp.filter = sqlite3_mprintf("pos = %d", pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(&qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return -1;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_fetch(&qp, queue_item, with_metadata);
db_query_end(&qp);
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
struct db_queue_item *
db_queue_fetch_bypos(uint32_t pos, char shuffle)
{
struct db_queue_item *queue_item;
int ret;
queue_item = calloc(1, sizeof(struct db_queue_item));
if (!queue_item)
{
DPRINTF(E_LOG, L_MAIN, "Out of memory for queue_item\n");
return NULL;
}
db_transaction_begin();
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_bypos(pos, shuffle, queue_item, 1);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
if (ret < 0)
{
free_queue_item(queue_item, 0);
DPRINTF(E_LOG, L_DB, "Error fetching queue item by pos id\n");
return NULL;
}
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
else if (queue_item->id == 0)
[player] Fix segfault if player reaches end of queue, fix repeat single
2016-11-12 12:45:54 -05:00
{
// No item found
free_queue_item(queue_item, 0);
return NULL;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return queue_item;
}
static int
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
queue_fetch_byposrelativetoitem(int pos, uint32_t item_id, char shuffle, struct db_queue_item *queue_item, int with_metadata)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
int pos_absolute;
int ret;
DPRINTF(E_DBG, L_DB, "Fetch by pos: pos (%d) relative to item with id (%d)\n", pos, item_id);
pos_absolute = db_queue_get_pos(item_id, shuffle);
if (pos_absolute < 0)
{
return -1;
}
DPRINTF(E_DBG, L_DB, "Fetch by pos: item (%d) has absolute pos %d\n", item_id, pos_absolute);
pos_absolute += pos;
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_bypos(pos_absolute, shuffle, queue_item, with_metadata);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[dacp/db] Fix issue found with scan-build - Result of operation is garbage or undefined in dacp_reply_cue_play - Uninitialized argument value in dacp_reply_playqueuecontents - Uninitialized argument value in queue_fetch_byposrelativetoitem
2017-01-20 11:03:45 -05:00
if (ret < 0)
DPRINTF(E_LOG, L_DB, "Error fetching item by pos: pos (%d) relative to item with id (%d)\n", pos, item_id);
else
DPRINTF(E_DBG, L_DB, "Fetch by pos: fetched item (id=%d, pos=%d, file-id=%d)\n", queue_item->id, queue_item->pos, queue_item->file_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
struct db_queue_item *
db_queue_fetch_byposrelativetoitem(int pos, uint32_t item_id, char shuffle)
{
struct db_queue_item *queue_item;
int ret;
DPRINTF(E_DBG, L_DB, "Fetch by pos: pos (%d) relative to item with id (%d)\n", pos, item_id);
queue_item = calloc(1, sizeof(struct db_queue_item));
if (!queue_item)
{
DPRINTF(E_LOG, L_MAIN, "Out of memory for queue_item\n");
return NULL;
}
db_transaction_begin();
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_byposrelativetoitem(pos, item_id, shuffle, queue_item, 1);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_transaction_end();
if (ret < 0)
{
free_queue_item(queue_item, 0);
DPRINTF(E_LOG, L_DB, "Error fetching queue item by pos relative to item id\n");
return NULL;
}
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
else if (queue_item->id == 0)
[player] Fix segfault if player reaches end of queue, fix repeat single
2016-11-12 12:45:54 -05:00
{
// No item found
free_queue_item(queue_item, 0);
return NULL;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
DPRINTF(E_DBG, L_DB, "Fetch by pos: fetched item (id=%d, pos=%d, file-id=%d)\n", queue_item->id, queue_item->pos, queue_item->file_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return queue_item;
}
struct db_queue_item *
db_queue_fetch_next(uint32_t item_id, char shuffle)
{
return db_queue_fetch_byposrelativetoitem(1, item_id, shuffle);
}
struct db_queue_item *
db_queue_fetch_prev(uint32_t item_id, char shuffle)
{
return db_queue_fetch_byposrelativetoitem(-1, item_id, shuffle);
}
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
static int
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_fix_pos(enum sort_type sort, int queue_version)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
#define Q_TMPL "UPDATE queue SET %q = %d, queue_version = %d WHERE id = %d and %q <> %d;"
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
struct query_params qp;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
char *query;
int pos;
int ret;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
memset(&qp, 0, sizeof(struct query_params));
qp.sort = sort;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(&qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
return -1;
}
pos = 0;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
while ((ret = queue_enum_fetch(&qp, &queue_item, 0)) == 0 && (queue_item.id > 0))
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
if (queue_item.pos != pos)
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
{
if (sort == S_SHUFFLE_POS)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf(Q_TMPL, "shuffle_pos", pos, queue_version, queue_item.id, "shuffle_pos", pos);
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
else
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf(Q_TMPL, "pos", pos, queue_version, queue_item.id, "pos", pos);
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
{
DPRINTF(E_LOG, L_DB, "Failed to update item with item-id: %d\n", queue_item.id);
break;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
pos++;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_query_end(&qp);
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
return ret;
#undef Q_TMPL
}
/*
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
* Remove files that are disabled or non existent in the library and repair ordering of
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
* the queue (shuffle and normal)
*/
int
db_queue_cleanup()
{
#define Q_TMPL "DELETE FROM queue WHERE NOT file_id IN (SELECT id from files WHERE disabled = 0);"
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
int deleted;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
ret = db_query_run(Q_TMPL, 0, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
deleted = sqlite3_changes(hdl);
if (deleted <= 0)
{
// Nothing to do
db_transaction_end();
return 0;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
// Update position of normal queue
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_fix_pos(S_POS, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Extract function to fix queue position values
2017-02-04 01:12:53 -05:00
// Update position of shuffle queue
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_fix_pos(S_SHUFFLE_POS, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return ret;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
#undef Q_TMPL
}
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
/*
* Removes all items from the queue except the item give by 'keep_item_id' (if 'keep_item_id' > 0).
*
* @param keep_item_id item-id (e. g. the now playing item) to be left in the queue
*/
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
db_queue_clear(uint32_t keep_item_id)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
char *query;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("DELETE FROM queue where id <> %d;", keep_item_id);
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
ret = db_query_run(query, 1, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
if (ret == 0 && keep_item_id)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = 0, shuffle_pos = 0, queue_version = %d where id = %d;", queue_version, keep_item_id);
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
ret = db_query_run(query, 1, 0);
}
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_transaction_end(ret, queue_version);
[dacp] Keep the now playing item in the queue when calling (#353) playqueueedit_clear
2017-02-11 03:28:35 -05:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
static int
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_delete_item(struct db_queue_item *queue_item, int queue_version)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
char *query;
int ret;
// Remove item with the given item_id
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
query = sqlite3_mprintf("DELETE FROM queue where id = %d;", queue_item->id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
{
return -1;
}
// Update pos for all items after the item with given item_id
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos - 1, queue_version = %d WHERE pos > %d;", queue_version, queue_item->pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
{
return -1;
}
// Update shuffle_pos for all items after the item with given item_id
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = shuffle_pos - 1, queue_version = %d WHERE shuffle_pos > %d;", queue_version, queue_item->shuffle_pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
{
return -1;
}
return 0;
}
int
db_queue_delete_byitemid(uint32_t item_id)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_byitemid(item_id, &queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
if (queue_item.id == 0)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
db_transaction_end();
return 0;
}
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_delete_item(&queue_item, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
int
db_queue_delete_bypos(uint32_t pos, int count)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Fix mpd command 'delete' removing to many items Previously db_queue_delete_bypos iterated over the items and called delete for each item. The delete also adjusted the pos/shuffle_pos values for the remaining items. A delete of pos = 0 resulted therefor in: - fetch item with pos = 0 - delete item at pos - update remaining items to pos = pos - 1 - fetch item with pos = 0 (returns the new item at pos 0) - delete item at pos - ...
2017-02-04 01:26:48 -05:00
char *query;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int to_pos;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Fix mpd command 'delete' removing to many items Previously db_queue_delete_bypos iterated over the items and called delete for each item. The delete also adjusted the pos/shuffle_pos values for the remaining items. A delete of pos = 0 resulted therefor in: - fetch item with pos = 0 - delete item at pos - update remaining items to pos = pos - 1 - fetch item with pos = 0 (returns the new item at pos 0) - delete item at pos - ...
2017-02-04 01:26:48 -05:00
// Remove item with the given item_id
to_pos = pos + count;
query = sqlite3_mprintf("DELETE FROM queue where pos >= %d AND pos < %d;", pos, to_pos);
ret = db_query_run(query, 1, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_fix_pos(S_POS, queue_version);
[db] Fix mpd command 'delete' removing to many items Previously db_queue_delete_bypos iterated over the items and called delete for each item. The delete also adjusted the pos/shuffle_pos values for the remaining items. A delete of pos = 0 resulted therefor in: - fetch item with pos = 0 - delete item at pos - update remaining items to pos = pos - 1 - fetch item with pos = 0 (returns the new item at pos 0) - delete item at pos - ...
2017-02-04 01:26:48 -05:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_fix_pos(S_SHUFFLE_POS, queue_version);
[db] Fix mpd command 'delete' removing to many items Previously db_queue_delete_bypos iterated over the items and called delete for each item. The delete also adjusted the pos/shuffle_pos values for the remaining items. A delete of pos = 0 resulted therefor in: - fetch item with pos = 0 - delete item at pos - update remaining items to pos = pos - 1 - fetch item with pos = 0 (returns the new item at pos 0) - delete item at pos - ...
2017-02-04 01:26:48 -05:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
int
db_queue_delete_byposrelativetoitem(uint32_t pos, uint32_t item_id, char shuffle)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_byposrelativetoitem(pos, item_id, shuffle, &queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
if (queue_item.id == 0)
[player] Fix segfault if player reaches end of queue, fix repeat single
2016-11-12 12:45:54 -05:00
{
// No item found
db_transaction_end();
return 0;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = queue_delete_item(&queue_item, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return ret;
}
/*
* Moves the queue item with the given id to the given position (zero-based).
*
* @param item_id Queue item id
* @param pos_to target position in the queue (zero-based)
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
* @þaram shuffle If 1 move item in the shuffle queue
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
* @return 0 on success, -1 on failure
*/
int
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
db_queue_move_byitemid(uint32_t item_id, int pos_to, char shuffle)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
char *query;
int pos_from;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Find item with the given item_id
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
pos_from = db_queue_get_pos(item_id, shuffle);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (pos_from < 0)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
ret = -1;
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
// Update pos for all items after the item with given item_id
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
if (shuffle)
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = shuffle_pos - 1, queue_version = %d WHERE shuffle_pos > %d;", queue_version, pos_from);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
else
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos - 1, queue_version = %d WHERE pos > %d;", queue_version, pos_from);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update pos for all items from the given pos_to
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
if (shuffle)
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = shuffle_pos + 1, queue_version = %d WHERE shuffle_pos >= %d;", queue_version, pos_to);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
else
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos + 1, queue_version = %d WHERE pos >= %d;", queue_version, pos_to);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update item with the given item_id
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
if (shuffle)
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = %d, queue_version = %d where id = %d;", pos_to, queue_version, item_id);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
else
[db] Update queue_version in db_queue_move_byitemid Fixes missing queue updates in MPDroid after moving an item in the queue. MPDroid moves items with the 'moveid' command and retrieves the playlist changes with the 'plchanges' command, due to the missing queue_version update the last command did not return any changes and the queue in MPDroid did not get updated.
2017-12-30 01:59:36 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = %d, queue_version = %d where id = %d;", pos_to, queue_version, item_id);
[dacp] Start playback from selected song in shuffle mode (#379)
2017-04-17 04:46:24 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return ret;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
/*
* Moves the queue item at the given position to the given position (zero-based).
*
* @param pos_from Position of the queue item to move
* @param pos_to target position in the queue (zero-based)
* @return 0 on success, -1 on failure
*/
int
db_queue_move_bypos(int pos_from, int pos_to)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
char *query;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Find item to move
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_bypos(pos_from, 0, &queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
if (queue_item.id == 0)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
db_transaction_end();
return 0;
}
// Update pos for all items after the item with given position
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos - 1, queue_version = %d WHERE pos > %d;", queue_version, queue_item.pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update pos for all items from the given pos_to
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos + 1, queue_version = %d WHERE pos >= %d;", queue_version, pos_to);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update item with the given item_id
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = %d, queue_version = %d where id = %d;", pos_to, queue_version, queue_item.id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return ret;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
/*
* Moves the queue item at the given position to the given target position. The positions
* are relavtive to the given base item (item id).
*
* @param from_pos Relative position of the queue item to the base item
* @param to_offset Target position relative to the base item
* @param item_id The base item id (normaly the now playing item)
* @return 0 on success, -1 on failure
*/
int
db_queue_move_byposrelativetoitem(uint32_t from_pos, uint32_t to_offset, uint32_t item_id, char shuffle)
{
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
int queue_version;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
char *query;
int pos_move_from;
int pos_move_to;
int ret;
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
queue_version = queue_transaction_begin();
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
DPRINTF(E_DBG, L_DB, "Move by pos: from %d offset %d relative to item (%d)\n", from_pos, to_offset, item_id);
// Find item with the given item_id
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_byitemid(item_id, &queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
DPRINTF(E_DBG, L_DB, "Move by pos: base item (id=%d, pos=%d, file-id=%d)\n", queue_item.id, queue_item.pos, queue_item.file_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
if (queue_item.id == 0)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
db_transaction_end();
return 0;
}
// Calculate the position of the item to move
if (shuffle)
pos_move_from = queue_item.shuffle_pos + from_pos;
else
pos_move_from = queue_item.pos + from_pos;
// Calculate the position where to move the item to
if (shuffle)
pos_move_to = queue_item.shuffle_pos + to_offset;
else
pos_move_to = queue_item.pos + to_offset;
if (pos_move_to < pos_move_from)
{
/*
* Moving an item to a previous position seems to send an offset incremented by one
*/
pos_move_to++;
}
DPRINTF(E_DBG, L_DB, "Move by pos: absolute pos: move from %d to %d\n", pos_move_from, pos_move_to);
// Find item to move
[db] Queue fetch functions should end the query after start and fetch
2016-12-04 03:30:21 -05:00
ret = queue_fetch_bypos(pos_move_from, shuffle, &queue_item, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
DPRINTF(E_DBG, L_DB, "Move by pos: move item (id=%d, pos=%d, file-id=%d)\n", queue_item.id, queue_item.pos, queue_item.file_id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
if (queue_item.id == 0)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
db_transaction_end();
return 0;
}
// Update pos for all items after the item with given position
if (shuffle)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = shuffle_pos - 1, queue_version = %d WHERE shuffle_pos > %d;", queue_version, queue_item.shuffle_pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos - 1, queue_version = %d WHERE pos > %d;", queue_version, queue_item.pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update pos for all items from the given pos_to
if (shuffle)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = shuffle_pos + 1, queue_version = %d WHERE shuffle_pos >= %d;", queue_version, pos_move_to);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = pos + 1, queue_version = %d WHERE pos >= %d;", queue_version, pos_move_to);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
goto end_transaction;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
// Update item with the given item_id
if (shuffle)
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = %d, queue_version = %d where id = %d;", pos_move_to, queue_version, queue_item.id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
else
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
query = sqlite3_mprintf("UPDATE queue SET pos = %d, queue_version = %d where id = %d;", pos_move_to, queue_version, queue_item.id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
end_transaction:
queue_transaction_end(ret, queue_version);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
return ret;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
/*
* Reshuffles the shuffle queue
*
* If the given item_id is 0, the whole shuffle queue is reshuffled, otherwise the
* queue is reshuffled after the item with the given id (excluding this item).
*
* @param item_id The base item, after this item the queue is reshuffled
* @return 0 on success, -1 on failure
*/
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
static int
queue_reshuffle(uint32_t item_id, int queue_version)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
char *query;
int pos;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
uint32_t count;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
struct db_queue_item queue_item;
int *shuffle_pos;
int len;
int i;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
struct query_params qp;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int ret;
DPRINTF(E_DBG, L_DB, "Reshuffle queue after item with item-id: %d\n", item_id);
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
// Reset the shuffled order and mark all items as changed
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = pos, queue_version = %d;", queue_version);
ret = db_query_run(query, 1, 0);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
return -1;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
pos = 0;
if (item_id > 0)
{
pos = db_queue_get_pos(item_id, 0);
if (pos < 0)
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
return -1;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
pos++; // Do not reshuffle the base item
}
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
ret = db_queue_get_count(&count);
if (ret < 0)
return -1;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
len = count - pos;
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
DPRINTF(E_DBG, L_DB, "Reshuffle %d items off %" PRIu32 " total items, starting from pos %d\n", len, count, pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
shuffle_pos = malloc(len * sizeof(int));
for (i = 0; i < len; i++)
{
shuffle_pos[i] = i + pos;
}
shuffle_int(&shuffle_rng, shuffle_pos, len);
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
memset(&qp, 0, sizeof(struct query_params));
qp.filter = sqlite3_mprintf("pos >= %d", pos);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
ret = queue_enum_start(&qp);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
{
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return -1;
}
i = 0;
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
while ((ret = queue_enum_fetch(&qp, &queue_item, 0)) == 0 && (queue_item.id > 0) && (i < len))
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
query = sqlite3_mprintf("UPDATE queue SET shuffle_pos = %d where id = %d;", shuffle_pos[i], queue_item.id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
ret = db_query_run(query, 1, 0);
if (ret < 0)
{
Rename "queue_item.item_id" to "queue_item.id"
2016-12-03 02:03:19 -05:00
DPRINTF(E_LOG, L_DB, "Failed to delete item with item-id: %d\n", queue_item.id);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
break;
}
i++;
}
[db] Align naming of struct query_params pointers et al
2017-04-16 17:54:07 -04:00
db_query_end(&qp);
sqlite3_free(qp.filter);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
if (ret < 0)
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
return -1;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
return 0;
}
[db] Update queue_version for changed queue items
2017-11-25 11:57:35 -05:00
/*
* Reshuffles the shuffle queue
*
* If the given item_id is 0, the whole shuffle queue is reshuffled, otherwise the
* queue is reshuffled after the item with the given id (excluding this item).
*
* @param item_id The base item, after this item the queue is reshuffled
* @return 0 on success, -1 on failure
*/
int
db_queue_reshuffle(uint32_t item_id)
{
int queue_version;
int ret;
queue_version = queue_transaction_begin();
ret = queue_reshuffle(item_id, queue_version);
queue_transaction_end(ret, queue_version);
return ret;
}
[player/db] Increment queue version if shuffle mode is turned off This fixes showing the wrong queue in the player web interface after turing shuffle mode off.
2018-11-05 15:35:17 -05:00
/*
* Increment queue version (triggers queue change event)
*/
int
db_queue_inc_version()
{
int queue_version;
queue_version = queue_transaction_begin();
queue_transaction_end(0, queue_version);
return 0;
}
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
int
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
db_queue_get_count(uint32_t *nitems)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
int ret = db_get_one_int("SELECT COUNT(*) FROM queue;");
if (ret < 0)
return -1;
*nitems = (uint32_t)ret;
return 0;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
}
/* Inotify */
int
db_watch_clear(void)
{
return db_query_run("DELETE FROM inotify;", 0, 0);
}
int
db_watch_add(struct watch_info *wi)
{
#define Q_TMPL "INSERT INTO inotify (wd, cookie, path) VALUES (%d, 0, '%q');"
char *query;
query = sqlite3_mprintf(Q_TMPL, wi->wd, wi->path);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
int
db_watch_delete_bywd(uint32_t wd)
{
#define Q_TMPL "DELETE FROM inotify WHERE wd = %d;"
char *query;
query = sqlite3_mprintf(Q_TMPL, wd);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
int
db_watch_delete_bypath(char *path)
{
#define Q_TMPL "DELETE FROM inotify WHERE path = '%q';"
char *query;
query = sqlite3_mprintf(Q_TMPL, path);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
int
db_watch_delete_bymatch(char *path)
{
#define Q_TMPL "DELETE FROM inotify WHERE path LIKE '%q/%%';"
char *query;
query = sqlite3_mprintf(Q_TMPL, path);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
int
db_watch_delete_bycookie(uint32_t cookie)
{
#define Q_TMPL "DELETE FROM inotify WHERE cookie = %" PRIi64 ";"
char *query;
if (cookie == 0)
return -1;
query = sqlite3_mprintf(Q_TMPL, (int64_t)cookie);
return db_query_run(query, 1, 0);
#undef Q_TMPL
}
static int
db_watch_get_byquery(struct watch_info *wi, char *query)
{
sqlite3_stmt *stmt;
char **strval;
char *cval;
uint32_t *ival;
int64_t cookie;
int ncols;
int i;
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
return -1;
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
DPRINTF(E_WARN, L_DB, "Watch not found: '%s'\n", query);
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
ncols = sqlite3_column_count(stmt);
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
if (ncols < ARRAY_SIZE(wi_cols_map))
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
[db/misc] Cast ARRAY_SIZE to unsigned (avoids compiler warnings)
2018-09-04 14:07:05 -04:00
DPRINTF(E_LOG, L_DB, "BUG: database has fewer columns (%d) than wi column map (%u)\n", ncols, ARRAY_SIZE(wi_cols_map));
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
for (i = 0; i < ARRAY_SIZE(wi_cols_map); i++)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
switch (wi_cols_map[i].type)
{
case DB_TYPE_INT:
ival = (uint32_t *) ((char *)wi + wi_cols_map[i].offset);
if (wi_cols_map[i].offset == wi_offsetof(cookie))
{
cookie = sqlite3_column_int64(stmt, i);
*ival = (cookie == INOTIFY_FAKE_COOKIE) ? 0 : cookie;
}
else
*ival = sqlite3_column_int(stmt, i);
break;
case DB_TYPE_STRING:
strval = (char **) ((char *)wi + wi_cols_map[i].offset);
cval = (char *)sqlite3_column_text(stmt, i);
if (cval)
*strval = strdup(cval);
break;
default:
DPRINTF(E_LOG, L_DB, "BUG: Unknown type %d in wi column map\n", wi_cols_map[i].type);
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
}
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
}
int
db_watch_get_bywd(struct watch_info *wi)
{
#define Q_TMPL "SELECT * FROM inotify WHERE wd = %d;"
char *query;
query = sqlite3_mprintf(Q_TMPL, wi->wd);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
return db_watch_get_byquery(wi, query);
#undef Q_TMPL
}
int
db_watch_get_bypath(struct watch_info *wi)
{
#define Q_TMPL "SELECT * FROM inotify WHERE path = '%q';"
char *query;
query = sqlite3_mprintf(Q_TMPL, wi->path);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
return db_watch_get_byquery(wi, query);
#undef Q_TMPL
}
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_watch_mark_bypath(char *path, enum strip_type strip, uint32_t cookie)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
#define Q_TMPL "UPDATE inotify SET path = substr(path, %d), cookie = %" PRIi64 " WHERE path = '%q';"
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, disabled, path);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_query_run(query, 1, 0);
#undef Q_TMPL
}
void
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
db_watch_mark_bymatch(char *path, enum strip_type strip, uint32_t cookie)
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
{
#define Q_TMPL "UPDATE inotify SET path = substr(path, %d), cookie = %" PRIi64 " WHERE path LIKE '%q/%%';"
char *query;
int64_t disabled;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
int path_striplen;
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
disabled = (cookie != 0) ? cookie : INOTIFY_FAKE_COOKIE;
[scan] Fix for issue #463, fname not getting updated on file rename Also modify code style of _enable/_disable functions in db.c
2017-12-16 17:09:29 -05:00
path_striplen = (strip == STRIP_PATH) ? strlen(path) : 0;
query = sqlite3_mprintf(Q_TMPL, path_striplen + 1, disabled, path);
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
db_query_run(query, 1, 0);
#undef Q_TMPL
}
void
Add watch-moving routines
2009-06-11 09:42:51 -04:00
db_watch_move_bycookie(uint32_t cookie, char *path)
{
#define Q_TMPL "UPDATE inotify SET path = '%q' || path, cookie = 0 WHERE cookie = %" PRIi64 ";"
char *query;
if (cookie == 0)
return;
query = sqlite3_mprintf(Q_TMPL, path, (int64_t)cookie);
Include DAAP queries from Retune and TunesRemote+ for caching + misc fixing up
2014-08-22 16:51:13 -04:00
db_query_run(query, 1, 0);
Add watch-moving routines
2009-06-11 09:42:51 -04:00
#undef Q_TMPL
}
int
db_watch_cookie_known(uint32_t cookie)
{
#define Q_TMPL "SELECT COUNT(*) FROM inotify WHERE cookie = %" PRIi64 ";"
char *query;
int ret;
if (cookie == 0)
return 0;
query = sqlite3_mprintf(Q_TMPL, (int64_t)cookie);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return 0;
}
[db] Rename db_get_count to db_get_one_int
2016-12-09 10:20:03 -05:00
ret = db_get_one_int(query);
Add watch-moving routines
2009-06-11 09:42:51 -04:00
sqlite3_free(query);
return (ret > 0);
#undef Q_TMPL
}
Add watch query/enumeration
2009-06-11 10:44:49 -04:00
int
db_watch_enum_start(struct watch_enum *we)
{
#define Q_MATCH_TMPL "SELECT wd FROM inotify WHERE path LIKE '%q/%%';"
#define Q_COOKIE_TMPL "SELECT wd FROM inotify WHERE cookie = %" PRIi64 ";"
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
sqlite3_stmt *stmt;
Add watch query/enumeration
2009-06-11 10:44:49 -04:00
char *query;
int ret;
we->stmt = NULL;
if (we->match)
query = sqlite3_mprintf(Q_MATCH_TMPL, we->match);
else if (we->cookie != 0)
query = sqlite3_mprintf(Q_COOKIE_TMPL, we->cookie);
else
{
DPRINTF(E_LOG, L_DB, "Could not start enum, no parameter given\n");
return -1;
}
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Starting enum '%s'\n", query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
Add watch query/enumeration
2009-06-11 10:44:49 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
sqlite3_free(query);
[db] Replace sqlite3_xxx() calls outside db.c/cache.c so they are abstracted
2017-10-14 14:16:34 -04:00
we->stmt = stmt;
Add watch query/enumeration
2009-06-11 10:44:49 -04:00
return 0;
#undef Q_MATCH_TMPL
#undef Q_COOKIE_TMPL
}
void
db_watch_enum_end(struct watch_enum *we)
{
if (!we->stmt)
return;
sqlite3_finalize(we->stmt);
we->stmt = NULL;
}
int
db_watch_enum_fetchwd(struct watch_enum *we, uint32_t *wd)
{
int ret;
*wd = 0;
if (!we->stmt)
{
DPRINTF(E_LOG, L_DB, "Watch enum not started!\n");
return -1;
}
Introduce and use db_blocking_{prepare_v2,step} Make use of the SQLite3 unlock notify API to wait for the database to become available. From the SQLite3 sample code for the unlock notify API. This requires SQLite3 to be built with SQLITE_ENABLE_UNLOCK_NOTIFY.
2010-04-26 12:24:09 -04:00
ret = db_blocking_step(we->stmt);
Add watch query/enumeration
2009-06-11 10:44:49 -04:00
if (ret == SQLITE_DONE)
{
DPRINTF(E_INFO, L_DB, "End of watch enum results\n");
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
return -1;
}
*wd = (uint32_t)sqlite3_column_int(we->stmt, 0);
return 0;
}
Add storage of inotify watch info
2009-06-10 12:11:11 -04:00
Add DB profiling support
2010-09-29 12:49:10 -04:00
#ifdef DB_PROFILE
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
static int
db_xprofile(unsigned int trace_type, void *notused, void *ptr, void *ptr_data)
Add DB profiling support
2010-09-29 12:49:10 -04:00
{
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
sqlite3_stmt *pstmt;
int64_t ms = 0;
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
sqlite3_stmt *stmt;
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
const char *pquery;
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
char *query;
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
int log_level;
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
int ret;
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
if (trace_type != SQLITE_TRACE_PROFILE)
return 0;
pstmt = ptr;
pquery = sqlite3_sql(pstmt);
ms = *((int64_t *) ptr_data) / 1000000;
if (ms > 1000)
log_level = E_LOG;
else if (ms > 500)
log_level = E_WARN;
else if (ms > 10)
log_level = E_DBG;
else
log_level = E_SPAM;
if (log_level > logger_severity())
return 0;
DPRINTF(log_level, L_DBPERF, "SQL PROFILE query: %s\n", pquery);
DPRINTF(log_level, L_DBPERF, "SQL PROFILE time: %" PRIi64 " ms\n", ms);
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
if ((strncmp(pquery, "SELECT", 6) != 0)
&& (strncmp(pquery, "UPDATE", 6) != 0)
&& (strncmp(pquery, "DELETE", 6) != 0))
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
return 0;
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
/* Disable profiling callback */
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
sqlite3_trace_v2(hdl, 0, NULL, NULL);
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
query = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", pquery);
if (!query)
{
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
DPRINTF(log_level, L_DBPERF, "Query plan: Out of memory\n");
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
goto out;
}
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
sqlite3_free(query);
if (ret != SQLITE_OK)
{
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
DPRINTF(log_level, L_DBPERF, "Query plan: Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
goto out;
}
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
DPRINTF(log_level, L_DBPERF, "Query plan:\n");
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
while ((ret = db_blocking_step(stmt)) == SQLITE_ROW)
{
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
DPRINTF(log_level, L_DBPERF, "(%d,%d,%d) %s\n",
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
sqlite3_column_int(stmt, 0), sqlite3_column_int(stmt, 1), sqlite3_column_int(stmt, 2),
sqlite3_column_text(stmt, 3));
}
if (ret != SQLITE_DONE)
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
DPRINTF(log_level, L_DBPERF, "Query plan: Could not step: %s\n", sqlite3_errmsg(hdl));
Add query plan to DB profiling callback
2011-06-11 10:59:25 -04:00
sqlite3_finalize(stmt);
out:
/* Reenable profiling callback */
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
sqlite3_trace_v2(hdl, SQLITE_TRACE_PROFILE, db_xprofile, NULL);
return 0;
Add DB profiling support
2010-09-29 12:49:10 -04:00
}
#endif
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
static int
db_pragma_get_cache_size()
{
sqlite3_stmt *stmt;
char *query = "PRAGMA cache_size;";
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
ret = db_blocking_step(stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of query results\n");
sqlite3_free(query);
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
ret = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
return ret;
}
static int
db_pragma_set_cache_size(int pages)
{
#define Q_TMPL "PRAGMA cache_size=%d;"
sqlite3_stmt *stmt;
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, pages);
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
add missing "#undef Q_TMPL"
2014-07-27 05:16:00 -04:00
#undef Q_TMPL
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
}
static char *
db_pragma_set_journal_mode(char *mode)
{
#define Q_TMPL "PRAGMA journal_mode=%s;"
sqlite3_stmt *stmt;
char *query;
int ret;
char *new_mode;
query = sqlite3_mprintf(Q_TMPL, mode);
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return NULL;
}
ret = db_blocking_step(stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of query results\n");
sqlite3_free(query);
return NULL;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return NULL;
}
new_mode = (char *) sqlite3_column_text(stmt, 0);
sqlite3_finalize(stmt);
sqlite3_free(query);
return new_mode;
#undef Q_TMPL
}
static int
db_pragma_get_synchronous()
{
sqlite3_stmt *stmt;
char *query = "PRAGMA synchronous;";
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
ret = db_blocking_step(stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of query results\n");
sqlite3_free(query);
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
ret = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
return ret;
}
static int
db_pragma_set_synchronous(int synchronous)
{
#define Q_TMPL "PRAGMA synchronous=%d;"
sqlite3_stmt *stmt;
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, synchronous);
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
add missing "#undef Q_TMPL"
2014-07-27 05:16:00 -04:00
#undef Q_TMPL
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
}
Add DB profiling support
2010-09-29 12:49:10 -04:00
Add option to enable memory-mapped I/O
2015-09-13 03:10:42 -04:00
static int
db_pragma_get_mmap_size()
{
sqlite3_stmt *stmt;
char *query = "PRAGMA mmap_size;";
int ret;
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
ret = db_blocking_step(stmt);
if (ret == SQLITE_DONE)
{
DPRINTF(E_DBG, L_DB, "End of query results\n");
sqlite3_free(query);
return 0;
}
else if (ret != SQLITE_ROW)
{
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
ret = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
return ret;
}
static int
db_pragma_set_mmap_size(int mmap_size)
{
#define Q_TMPL "PRAGMA mmap_size=%d;"
sqlite3_stmt *stmt;
char *query;
int ret;
query = sqlite3_mprintf(Q_TMPL, mmap_size);
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return 0;
}
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
#undef Q_TMPL
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
static int
db_open(void)
Add new database code
2009-06-07 12:56:35 -04:00
{
Load our SQLite extension
2010-09-28 12:38:10 -04:00
char *errmsg;
Add new database code
2009-06-07 12:56:35 -04:00
int ret;
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
int cache_size;
char *journal_mode;
int synchronous;
Add option to enable memory-mapped I/O
2015-09-13 03:10:42 -04:00
int mmap_size;
Add new database code
2009-06-07 12:56:35 -04:00
Make database location a configuration item
2010-03-21 06:33:05 -04:00
ret = sqlite3_open(db_path, &hdl);
Add new database code
2009-06-07 12:56:35 -04:00
if (ret != SQLITE_OK)
{
[db] Log path to db on error, so it's easier to debug
2017-10-29 17:07:58 -04:00
DPRINTF(E_LOG, L_DB, "Could not open '%s': %s\n", db_path, sqlite3_errmsg(hdl));
Add new database code
2009-06-07 12:56:35 -04:00
sqlite3_close(hdl);
return -1;
}
Load our SQLite extension
2010-09-28 12:38:10 -04:00
ret = sqlite3_enable_load_extension(hdl, 1);
Make daap_songalbumid available as a function inside SQLite
2010-01-04 12:00:40 -05:00
if (ret != SQLITE_OK)
{
Load our SQLite extension
2010-09-28 12:38:10 -04:00
DPRINTF(E_LOG, L_DB, "Could not enable extension loading\n");
sqlite3_close(hdl);
return -1;
}
errmsg = NULL;
ret = sqlite3_load_extension(hdl, PKGLIBDIR "/forked-daapd-sqlext.so", NULL, &errmsg);
if (ret != SQLITE_OK)
{
if (errmsg)
{
DPRINTF(E_LOG, L_DB, "Could not load SQLite extension: %s\n", errmsg);
sqlite3_free(errmsg);
}
else
DPRINTF(E_LOG, L_DB, "Could not load SQLite extension: %s\n", sqlite3_errmsg(hdl));
Make daap_songalbumid available as a function inside SQLite
2010-01-04 12:00:40 -05:00
sqlite3_close(hdl);
return -1;
}
Load our SQLite extension
2010-09-28 12:38:10 -04:00
ret = sqlite3_enable_load_extension(hdl, 0);
Introduce DAAP-specific collation function for SQLite
2010-08-29 04:21:35 -04:00
if (ret != SQLITE_OK)
{
Load our SQLite extension
2010-09-28 12:38:10 -04:00
DPRINTF(E_LOG, L_DB, "Could not disable extension loading\n");
Introduce DAAP-specific collation function for SQLite
2010-08-29 04:21:35 -04:00
sqlite3_close(hdl);
return -1;
}
Add DB profiling support
2010-09-29 12:49:10 -04:00
#ifdef DB_PROFILE
[dbperf] Use sqlite3_trace_v2 instead of deprecated sqlite3_profile Set log severity depending on how long the query was running and return early if log level is lower than the current one.
2018-01-13 04:48:44 -05:00
sqlite3_trace_v2(hdl, SQLITE_TRACE_PROFILE, db_xprofile, NULL);
Add DB profiling support
2010-09-29 12:49:10 -04:00
#endif
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
cache_size = cfg_getint(cfg_getsec(cfg, "sqlite"), "pragma_cache_size_library");
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
if (cache_size > -1)
{
db_pragma_set_cache_size(cache_size);
cache_size = db_pragma_get_cache_size();
DPRINTF(E_DBG, L_DB, "Database cache size in pages: %d\n", cache_size);
}
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
journal_mode = cfg_getstr(cfg_getsec(cfg, "sqlite"), "pragma_journal_mode");
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
if (journal_mode)
{
journal_mode = db_pragma_set_journal_mode(journal_mode);
DPRINTF(E_DBG, L_DB, "Database journal mode: %s\n", journal_mode);
}
Artwork caching (pull request #61), and also: - introduced new section in config file for sqlite pragma settings, added config for artwork cache - added setting of pragma synchronous, cache size and journal mode to daap cache
2014-11-10 16:53:08 -05:00
synchronous = cfg_getint(cfg_getsec(cfg, "sqlite"), "pragma_synchronous");
Added options to modify the operation of the SQLite database (through PRAGMA statements) - set cache size (in number of pages) - set synchronous flag - set journal mode
2014-06-08 02:25:58 -04:00
if (synchronous > -1)
{
db_pragma_set_synchronous(synchronous);
synchronous = db_pragma_get_synchronous();
DPRINTF(E_DBG, L_DB, "Database synchronous: %d\n", synchronous);
}
Add option to enable memory-mapped I/O
2015-09-13 03:10:42 -04:00
mmap_size = cfg_getint(cfg_getsec(cfg, "sqlite"), "pragma_mmap_size_library");
if (mmap_size > -1)
{
db_pragma_set_mmap_size(mmap_size);
mmap_size = db_pragma_get_mmap_size();
DPRINTF(E_DBG, L_DB, "Database mmap_size: %d\n", mmap_size);
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
return 0;
}
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
static sqlite3_stmt *
db_statements_prepare_insert(const struct col_type_map *map, size_t map_size, const char *table)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
char *query;
char keystr[2048];
char valstr[1024];
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
sqlite3_stmt *stmt;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
int ret;
int i;
[misc] New utility functions: trim, atrim and safe_snprintf_cat
2018-10-06 17:27:54 -04:00
memset(keystr, 0, sizeof(keystr));
memset(valstr, 0, sizeof(valstr));
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
for (i = 0; i < map_size; i++)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (map[i].flag & DB_FLAG_NO_BIND)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
continue;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
CHECK_ERR(L_DB, safe_snprintf_cat(keystr, sizeof(keystr), "%s, ", map[i].name));
[misc] New utility functions: trim, atrim and safe_snprintf_cat
2018-10-06 17:27:54 -04:00
CHECK_ERR(L_DB, safe_snprintf_cat(valstr, sizeof(valstr), "?, "));
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
}
[misc] New utility functions: trim, atrim and safe_snprintf_cat
2018-10-06 17:27:54 -04:00
// Terminate at the ending ", "
*(strrchr(keystr, ',')) = '\0';
*(strrchr(valstr, ',')) = '\0';
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
CHECK_NULL(L_DB, query = db_mprintf("INSERT INTO %s (%s) VALUES (%s);", table, keystr, valstr));
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DB, "Could not prepare statement '%s': %s\n", query, sqlite3_errmsg(hdl));
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return NULL;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
}
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return stmt;
}
static sqlite3_stmt *
db_statements_prepare_update(const struct col_type_map *map, size_t map_size, const char *table)
{
char *query;
char keystr[2048];
sqlite3_stmt *stmt;
int ret;
int i;
[misc] New utility functions: trim, atrim and safe_snprintf_cat
2018-10-06 17:27:54 -04:00
memset(keystr, 0, sizeof(keystr));
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
for (i = 0; i < map_size; i++)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (map[i].flag & DB_FLAG_NO_BIND)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
continue;
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
if (map[i].flag & DB_FLAG_NO_ZERO)
CHECK_ERR(L_DB, safe_snprintf_cat(keystr, sizeof(keystr), "%s = daap_no_zero(?, %s), ", map[i].name, map[i].name));
[db] Don't zero play_count, skip_count, seek, time_played, time_skipped on update If a file gets updated/rescanned we generally don't want to reset the above values. This commit adds DB_FLAG_NO_ZERO, which marks a field so that db_file_update() will only update it if the new value is non-zero (i.e. the caller probably has a "better" value).
2018-12-30 15:55:55 -05:00
else
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
CHECK_ERR(L_DB, safe_snprintf_cat(keystr, sizeof(keystr), "%s = ?, ", map[i].name));
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
}
[misc] New utility functions: trim, atrim and safe_snprintf_cat
2018-10-06 17:27:54 -04:00
// Terminate at the ending ", "
*(strrchr(keystr, ',')) = '\0';
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
CHECK_NULL(L_DB, query = db_mprintf("UPDATE %s SET %s WHERE %s = ?;", table, keystr, map[0].name));
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DB, "Could not prepare statement '%s': %s\n", query, sqlite3_errmsg(hdl));
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return NULL;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
}
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return stmt;
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
static sqlite3_stmt *
db_statements_prepare_ping(const char *table)
{
char *query;
sqlite3_stmt *stmt;
int ret;
CHECK_NULL(L_DB, query = db_mprintf("UPDATE %s SET db_timestamp = ?, disabled = 0 WHERE path = ? AND db_timestamp >= ?;", table));
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DB, "Could not prepare statement '%s': %s\n", query, sqlite3_errmsg(hdl));
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return NULL;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
}
free(query);
[db] Use prepared statements for playlists (add/update)
2019-12-27 18:04:43 -05:00
return stmt;
}
static int
db_statements_prepare(void)
{
db_statements.files_insert = db_statements_prepare_insert(mfi_cols_map, ARRAY_SIZE(mfi_cols_map), "files");
db_statements.files_update = db_statements_prepare_update(mfi_cols_map, ARRAY_SIZE(mfi_cols_map), "files");
db_statements.files_ping = db_statements_prepare_ping("files");
db_statements.playlists_insert = db_statements_prepare_insert(pli_cols_map, ARRAY_SIZE(pli_cols_map), "playlists");
db_statements.playlists_update = db_statements_prepare_update(pli_cols_map, ARRAY_SIZE(pli_cols_map), "playlists");
if ( !db_statements.files_insert || !db_statements.files_update || !db_statements.files_ping
|| !db_statements.playlists_insert || !db_statements.playlists_update
)
return -1;
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
return 0;
}
int
db_perthread_init(void)
{
int ret;
ret = db_open();
if (ret < 0)
return -1;
ret = db_statements_prepare();
if (ret < 0)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statements\n");
sqlite3_close(hdl);
return -1;
}
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
void
db_perthread_deinit(void)
{
sqlite3_stmt *stmt;
Protect db_perthread_deinit() against NULL hdl
2010-07-17 06:48:11 -04:00
if (!hdl)
return;
Add new database code
2009-06-07 12:56:35 -04:00
/* Tear down anything that's in flight */
while ((stmt = sqlite3_next_stmt(hdl, 0)))
sqlite3_finalize(stmt);
sqlite3_close(hdl);
}
Set and check database schema version
2009-06-08 12:41:59 -04:00
static int
db_check_version(void)
{
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
#define Q_VACUUM "VACUUM;"
char *errmsg;
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
int db_ver_major;
int db_ver_minor;
int db_ver;
int vacuum;
Set and check database schema version
2009-06-08 12:41:59 -04:00
int ret;
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
vacuum = cfg_getbool(cfg_getsec(cfg, "sqlite"), "vacuum");
Set and check database schema version
2009-06-08 12:41:59 -04:00
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
db_ver_major = db_admin_getint(DB_ADMIN_SCHEMA_VERSION_MAJOR);
[db] Functions to read/store int in the admin table and introduce constants for admin table keys
2017-11-19 01:46:28 -05:00
if (!db_ver_major)
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
db_ver_major = db_admin_getint(DB_ADMIN_SCHEMA_VERSION); // Pre schema v15.1
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
[db] Functions to read/store int in the admin table and introduce constants for admin table keys
2017-11-19 01:46:28 -05:00
if (!db_ver_major)
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
return 1; // Will create new database
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
db_ver_minor = db_admin_getint(DB_ADMIN_SCHEMA_VERSION_MINOR);
Set and check database schema version
2009-06-08 12:41:59 -04:00
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
db_ver = db_ver_major * 100 + db_ver_minor;
[db] Drop upgrade support for pre-v17 db versions Also drop the old way of recreating the files table, it is now replaced by db_table_upgrade().
2018-12-29 18:39:42 -05:00
if (db_ver_major < 17)
Set and check database schema version
2009-06-08 12:41:59 -04:00
{
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
DPRINTF(E_FATAL, L_DB, "Database schema v%d too old, cannot upgrade\n", db_ver_major);
Set and check database schema version
2009-06-08 12:41:59 -04:00
return -1;
}
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
else if (db_ver_major > SCHEMA_VERSION_MAJOR)
Remove database upgrade for schema version before 10 (v0.12)
2011-03-15 16:24:39 -04:00
{
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
DPRINTF(E_FATAL, L_DB, "Database schema v%d is newer than the supported version\n", db_ver_major);
Remove database upgrade for schema version before 10 (v0.12)
2011-03-15 16:24:39 -04:00
return -1;
}
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
else if (db_ver < (SCHEMA_VERSION_MAJOR * 100 + SCHEMA_VERSION_MINOR))
Set and check database schema version
2009-06-08 12:41:59 -04:00
{
Adjust a few log messages
2015-01-14 14:46:03 -05:00
DPRINTF(E_LOG, L_DB, "Database schema outdated, upgrading schema v%d.%d -> v%d.%d...\n",
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
db_ver_major, db_ver_minor, SCHEMA_VERSION_MAJOR, SCHEMA_VERSION_MINOR);
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
ret = sqlite3_exec(hdl, "BEGIN TRANSACTION;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
{
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
DPRINTF(E_LOG, L_DB, "DB error while running 'BEGIN TRANSACTION': %s\n", errmsg);
Add artwork field to db (upgrade to v15). Set field when embedded artwork found by the filescanner. Reenable support for embedded artwork in group requests.
2014-01-11 17:05:29 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
sqlite3_free(errmsg);
return -1;
}
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
// Will drop indices and triggers
[db] Move database upgrade logic to separate file
2015-12-19 01:51:10 -05:00
ret = db_upgrade(hdl, db_ver);
if (ret < 0)
{
DPRINTF(E_LOG, L_DB, "Database upgrade errored out, rolling back changes ...\n");
ret = sqlite3_exec(hdl, "ROLLBACK TRANSACTION;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "DB error while running 'ROLLBACK TRANSACTION': %s\n", errmsg);
sqlite3_free(errmsg);
}
return -1;
}
[db] Move initialization of new db into its own file (db_init.c)
2016-11-04 02:10:36 -04:00
ret = db_init_indices(hdl);
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
if (ret < 0)
{
DPRINTF(E_LOG, L_DB, "Database upgrade errored out, rolling back changes ...\n");
ret = sqlite3_exec(hdl, "ROLLBACK TRANSACTION;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "DB error while running 'ROLLBACK TRANSACTION': %s\n", errmsg);
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
sqlite3_free(errmsg);
}
Initial support for mpd protocol
2014-12-21 14:41:44 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
return -1;
[db] Recreate v20 files table, so that new constraints take effect if upgrading The constraints on songalbumid and songartistid where changed with v20, so we need to make sure they take effect when upgrading. This commit tries to do the table recreation like sqlite recommends and without manually crafted copy queries that are probably prone to errors. Since we are recreating anyway, this commit also reorders the columns slightly. It also includes auto-drop/recreation of triggers (should really have been its own commit) during upgrade, like is already done with indices.
2018-12-29 18:27:47 -05:00
}
ret = db_init_triggers(hdl);
if (ret < 0)
{
DPRINTF(E_LOG, L_DB, "Database upgrade errored out, rolling back changes ...\n");
ret = sqlite3_exec(hdl, "ROLLBACK TRANSACTION;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "DB error while running 'ROLLBACK TRANSACTION': %s\n", errmsg);
sqlite3_free(errmsg);
}
return -1;
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
}
Upgrade database schema to v15.0 -> 15.1
2015-01-14 14:37:29 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
ret = sqlite3_exec(hdl, "COMMIT TRANSACTION;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "DB error while running 'COMMIT TRANSACTION': %s\n", errmsg);
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
sqlite3_free(errmsg);
return -1;
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
}
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
DPRINTF(E_LOG, L_DB, "Upgrading schema to v%d.%d completed\n", SCHEMA_VERSION_MAJOR, SCHEMA_VERSION_MINOR);
Remove upgrade paths for indices (since they don't have any data anyway), and instead implement db_create_indices and db_drop_indices to reduce redundancy
2015-01-08 18:28:06 -05:00
Enclose DB upgrade in a single transaction (improves performance and in case of an error does a rollback, keeping the db in a valid state)
2015-02-26 08:09:14 -05:00
vacuum = 1;
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
}
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
else if (db_ver_minor > SCHEMA_VERSION_MINOR)
{
DPRINTF(E_LOG, L_DB, "Future (but compatible) database version detected (v%d.%d)\n", db_ver_major, db_ver_minor);
}
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
if (vacuum)
Set and check database schema version
2009-06-08 12:41:59 -04:00
{
Adjust a few log messages
2015-01-14 14:46:03 -05:00
DPRINTF(E_LOG, L_DB, "Now vacuuming database, this may take some time...\n");
Vacuum on startup and also make index changes possible without schema updates
2015-01-10 16:44:26 -05:00
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
ret = sqlite3_exec(hdl, Q_VACUUM, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not VACUUM database: %s\n", errmsg);
Set and check database schema version
2009-06-08 12:41:59 -04:00
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
sqlite3_free(errmsg);
return -1;
}
}
Vacuum on startup and also make index changes possible without schema updates
2015-01-10 16:44:26 -05:00
Set and check database schema version
2009-06-08 12:41:59 -04:00
return 0;
Handle database schema upgrade from v1 to v2
2009-12-26 03:18:56 -05:00
#undef Q_VACUUM
Set and check database schema version
2009-06-08 12:41:59 -04:00
}
Add new database code
2009-06-07 12:56:35 -04:00
int
db_init(void)
{
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
uint32_t files;
uint32_t pls;
Add new database code
2009-06-07 12:56:35 -04:00
int ret;
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
if (ARRAY_SIZE(dbmfi_cols_map) != ARRAY_SIZE(mfi_cols_map))
{
DPRINTF(E_FATAL, L_DB, "BUG: mfi column maps are not in sync\n");
return -1;
}
if (ARRAY_SIZE(dbpli_cols_map) != ARRAY_SIZE(pli_cols_map))
{
DPRINTF(E_FATAL, L_DB, "BUG: pli column maps are not in sync\n");
return -1;
}
Make database location a configuration item
2010-03-21 06:33:05 -04:00
db_path = cfg_getstr(cfg_getsec(cfg, "general"), "db_path");
[db/conf] Add automatic calculation of ratings based on played/skipped If activated in the configuration file, rating is updated after playing or skipping a song. The calculation is based on how it is done in the mpdstats plugin for beets (https://beets.readthedocs.io/en/latest/plugins/mpdstats.html).
2018-08-19 03:45:35 -04:00
db_rating_updates = cfg_getbool(cfg_getsec(cfg, "library"), "rating_updates");
Make database location a configuration item
2010-03-21 06:33:05 -04:00
[db] Be forwards compatible with tables that have additional columns
2018-09-02 17:38:46 -04:00
DPRINTF(E_LOG, L_DB, "Configured to use database file '%s'\n", db_path);
Switch SQLite3 to SQLITE_CONFIG_MULTITHREAD mode
2010-04-26 12:24:09 -04:00
ret = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
Perform explicit sqlite3 init/deinit
2010-04-26 12:24:09 -04:00
if (ret != SQLITE_OK)
{
Switch SQLite3 to SQLITE_CONFIG_MULTITHREAD mode
2010-04-26 12:24:09 -04:00
DPRINTF(E_FATAL, L_DB, "Could not switch SQLite3 to multithread mode\n");
DPRINTF(E_FATAL, L_DB, "Check that SQLite3 has been configured for thread-safe operations\n");
Perform explicit sqlite3 init/deinit
2010-04-26 12:24:09 -04:00
return -1;
}
Enable SQLite3 shared-cache mode This requires SQLite 3.5.0+ for per-process (as opposed to per-thread) shared-cache support. It also enables the use of the unlock notify API.
2010-04-27 13:46:39 -04:00
ret = sqlite3_enable_shared_cache(1);
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DB, "Could not enable SQLite3 shared-cache mode\n");
return -1;
}
Switch SQLite3 to SQLITE_CONFIG_MULTITHREAD mode
2010-04-26 12:24:09 -04:00
ret = sqlite3_initialize();
if (ret != SQLITE_OK)
Add new database code
2009-06-07 12:56:35 -04:00
{
Switch SQLite3 to SQLITE_CONFIG_MULTITHREAD mode
2010-04-26 12:24:09 -04:00
DPRINTF(E_FATAL, L_DB, "SQLite3 failed to initialize\n");
Add new database code
2009-06-07 12:56:35 -04:00
return -1;
}
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
ret = db_open();
Add new database code
2009-06-07 12:56:35 -04:00
if (ret < 0)
[db] Use prepared statements for file insert, update and ping Get rid of the SQL query strings, since they are prone to errors and are probably also slower that using prepared statements.
2018-09-23 16:24:24 -04:00
{
DPRINTF(E_FATAL, L_DB, "Could not open database\n");
return -1;
}
Add new database code
2009-06-07 12:56:35 -04:00
Set and check database schema version
2009-06-08 12:41:59 -04:00
ret = db_check_version();
if (ret < 0)
Rework database version check to error out on newer databases
2010-04-27 14:48:46 -04:00
{
DPRINTF(E_FATAL, L_DB, "Database version check errored out, incompatible database\n");
db_perthread_deinit();
return -1;
}
else if (ret > 0)
Set and check database schema version
2009-06-08 12:41:59 -04:00
{
Introduce major and minor schema versioning to improve vers compability - also make database vacuuming on startup optional
2015-01-14 14:32:36 -05:00
DPRINTF(E_LOG, L_DB, "Could not check database version, trying DB init\n");
Check database version first, if that fails, try DB init Doing it the other way around is a guaranteed way to run into issues when a schema upgrade is needed.
2010-01-21 11:51:00 -05:00
[db] Move initialization of new db into its own file (db_init.c)
2016-11-04 02:10:36 -04:00
ret = db_init_tables(hdl);
Check database version first, if that fails, try DB init Doing it the other way around is a guaranteed way to run into issues when a schema upgrade is needed.
2010-01-21 11:51:00 -05:00
if (ret < 0)
{
DPRINTF(E_FATAL, L_DB, "Could not create tables\n");
db_perthread_deinit();
return -1;
}
Set and check database schema version
2009-06-08 12:41:59 -04:00
}
Configurable library names Names of Library, Music, Movies, TV Shows and Podcasts made configurable
2013-11-30 06:57:38 -05:00
db_set_cfg_names();
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
CHECK_ERR(L_DB, db_files_get_count(&files, NULL, NULL));
CHECK_ERR(L_DB, db_pl_get_count(&pls));
[db] Rename 'ADMIN_*' defines to 'DB_ADMIN_*'
2017-11-19 15:14:41 -05:00
db_admin_setint64(DB_ADMIN_START_TIME, (int64_t) time(NULL));
Add new database code
2009-06-07 12:56:35 -04:00
db_perthread_deinit();
[db] Speed up Q_PL query used by e.g. '/databases/1/containers' request The previous solution would use subqueries to count the number of items and streams in each playlist, which means that response time gets pretty slow if there are many playlists. This commit also includes a number of lesser db code changes.
2019-05-28 17:40:41 -04:00
DPRINTF(E_LOG, L_DB, "Database OK with %" PRIu32 " active files and %" PRIu32 " active playlists\n", files, pls);
Add new database code
2009-06-07 12:56:35 -04:00
[db] Add functions to access/modify the queue table
2016-11-04 10:34:00 -04:00
rng_init(&shuffle_rng);
Add new database code
2009-06-07 12:56:35 -04:00
return 0;
}
Perform explicit sqlite3 init/deinit
2010-04-26 12:24:09 -04:00
void
db_deinit(void)
{
sqlite3_shutdown();
}
Reference in New Issue Copy Permalink