# $Id$

=for comment (License)

##############################################################################
#
# configDB.pm
#
# A fhem library to enable configuration from sql database
# instead of plain text file, e.g. fhem.cfg
#
# READ COMMANDREF DOCUMENTATION FOR CORRECT USE!
#
# Copyright: betateilchen ®
#
# This file is part of fhem.
#
# Fhem 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.
#
# Fhem 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 fhem. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
=cut

=for comment (changelog before 2022)
#
# ChangeLog
#
# 2014-03-01 - SVN 5080 - initial release of interface inside fhem.pl
#            - initial release of configDB.pm
#
# 2014-03-02 - added     template files for sqlite in contrib/configDB
#            - updated   commandref (EN) documentation
#            - added     commandref (DE) documentation
#
# 2014-03-03 - changed   performance optimized by using version uuid table
#            - updated   commandref docu for migration
#            - added     cfgDB_svnId for fhem.pl CommandVersion
#            - added     cfgDB_List to show device info from database
#            - updated   commandref docu for cfgDB_List
#
# 2014-03-06 - added     cfgDB_Diff to compare device in two versions
#
# 2014-03-07 - changed   optimized cfgDB_Diff
#                        restructured libraray internally
#                        improved source code documentation
#
# 2014-03-20 - added     export/import
# 2014-04-01 - removed   export/import due to not working properly
#
# 2014-04-03 - fixed     global attributes not read from version 0
#
# 2014-04-18 - added     commands fileimport, fileexport
# 2014-04-19 - added     commands filelist, filedelete
#                        interface cfgDB_Readfile for interaction
#                        with other modules
#
# 2014-04-21 - added     interface functions for FHEMWEB and fhem.pl
#                        to show files in "Edit files" and use them
#                        with CommandReload() mechanism
#
#              modified  _cfgDB_Info to show number of files in db
#
# 2014-04-23 - added     command fileshow, filemove
#
# 2014-04-26 - added     migration to generic file handling
#              fixed     problem on migration of multiline DEFs
#
# 2014-04-27 - added     new functions for binfile handling
#
# 2014-05-11 - removed   command binfileimport
#              changed   store all files as binary
#              added     _cfgDB_Move to move all files from text 
#                        to binary filesave on first load of configDB
#
# 2014-05-12 - added     sorted write & read for config data
#
# 2014-05-15 - fixed     handling of multiline defs
#
# 2014-05-20 - removed   no longer needed functions for file handling
#              changed   code improvement; use strict; use warnings;
#
# 2014-08-22 - added     automatic fileimport during migration
#
# 2014-09-30 - added     support for device based userattr
#
# 2015-01-12 - changed   use fhem function createUniqueId()
#                        instead of database calls
#
# 2015-01-15 - changed   remove 99_Utils.pm from filelist
#
# 2015-01-17 - added     configdb diff all current
#                        shows diff table between version 0
#                        and currently running version (in memory)
#
# 2015-01-23 - changed   attribute handling for internal configDB attrs
#
# 2015-01-23 - added     FileRead() caching - experimental
#
# 2015-10-14 - changed   search conditions use ESCAPE, forum #42190
#
# 2016-03-19 - changed   use modpath, forum #51036
#
# 2016-03-26 - added     log entry for search (verbose=5)
#
# 2016-05-22 - added     configdb dump (for sqlite)
#
# 2016-05-28 - added     configdb dump (for mysql)
#
# 2016-05-29 - changed   improve support for postgresql (tnx to Matze)
#              added     configdb dump (for postgresql)
#
# 2016-07-03 - added     support for multiple hosts (experimental)
# 2016-07-04 - fixed     improve config file read
# 2016-07-07 - bugfix    select configuration
#
# 2017-03-24 - added     use index on fhemconfig (only sqlite)
#
# 2017-07-17 - changed   store files base64 encoded
#
# 2017-08-31 - changed   improve table_info for migration check
#
# 2018-02-17 - changed   remove experimenatal cache functions
# 2018-02-18 - changed   move dump processing to backend
#
# 2018-03-24 - changed   set privacy as default for username and password
# 2018-03-25 - changed   move rescue modes from ENV to config file
#
# 2018-06-17 - changed   remove migration on FHEM start by default
#                        check migration only if parameter migrate => 1 
#                        is set in configDB.conf
#
# 2018-07-04 - bugfix    change rescue mode persistence
#
# 2018-07-07 - change    lastReorg added to info output
#
# 2018-09-08 - change    remove base64 migration functions
#
# 2019-01-17 - added     support for device specific uuid (setuuid)
# 2019-01-18 - changed   use GetDefAndAttr()
#
# 2019-02-16 - changed   default field length for table creation
#
# 2020-02-25 - added     support weekprofile in automatic migration
#
# 2020-06-37 - added     support for special strange readings (length check)
#
# 2020-06-29 - added     support for mysqldump parameter by attribute
#
# 2020-07-02 - changed   code cleanup after last changes (remove debug code)
#                        add "configdb attr ?" to show known attributes
#
# 2021-04-17 - bugfix    problem in File.* commands regarding case sensitivity
#
# 2021-08-17 - changed   adopt to Rudi's funny fakelog changes
#
# 2021-10-24 - added     delete old files for large readings
#
=cut

=for comment (changelog starting 2022)
##############################################################################
#
# 2022-02-20 - changed   use createUniqueId() for uuids
#                        remove _cfgDB_Uuid()
#
# 2022-02-20 - added     statefile versioning - begin
# 2022-03-03             statefile versioning - completed
#
# 2022-03-14 - fixed     statefile problems with POSTGRESQL
# 2022-08-06 - added     attribute shortinfo for use with configdb info
# 2022-08-07 - added     log a message if more than 20 versions stored
#
# 2022-12-06 - added     add raw json output in configdb info
#
# 2023-08-07 - fixed     missing uuid in migration process
#
# 2023-08-23 - added     show version counter in save message
#
##############################################################################
=cut

use strict;
use warnings;
use Text::Diff;
use DBI;
use Sys::Hostname;
use MIME::Base64;

##################################################
# Forward declarations for functions in fhem.pl
#
## no critic
sub AnalyzeCommandChain($$;$);
sub GetDefAndAttr($;$);
sub Log($$);
sub createUniqueId();
## use critic

##################################################
# Forward declarations inside this library
#
sub cfgDB_AttrRead;
sub cfgDB_ReadAll;
sub cfgDB_Init;
sub cfgDB_FileRead;
sub cfgDB_FileUpdate;
sub cfgDB_Fileversion;
sub cfgDB_FileWrite;
sub cfgDB_FW_fileList;
sub cfgDB_Read99;
sub cfgDB_SaveCfg;
sub cfgDB_SaveState;
sub cfgDB_svnId;

sub _cfgDB_binFileimport;
sub _cfgDB_Connect;
sub _cfgDB_DeleteTemp;
sub _cfgDB_Diff;
sub __cfgDB_Diff;
sub _cfgDB_InsertLine;
sub _cfgDB_Execute;
sub _cfgDB_Filedelete;
sub _cfgDB_Fileexport;
sub _cfgDB_Filelist;
sub _cfgDB_Info;
sub _cfgDB_Migrate;
sub _cfgDB_ReadCfg;
sub _cfgDB_ReadState;
sub _cfgDB_Recover;
sub _cfgDB_Reorg;
sub _cfgDB_Rotate;
sub _cfgDB_Search;
sub _cfgDB_table_exists;
sub _cfgDB_dump;
sub _cfgDB_knownAttr;
sub _cfgDB_deleteRF;
sub _cfgDB_deleteStatefiles;

##################################################
# Read configuration file for DB connection
#


my ($err,@c) = FileRead({FileName  => 'configDB.conf', 
                           ForceType => "file"}); 
return 0 if ($err);

my @config;

foreach my $line (@c) {
   $line =~ s/^\s+|\s+$//g; # remove whitespaces etc.
   $line =~ s/;$/;;/;       # duplicate ; at end-of-line
   push (@config,$line) if($line !~ m/^#/ && length($line) > 0);
}

use vars qw(%configDB);

my %dbconfig;

my $configs  = join("",@config);
my @configs  = split(/;;/,$configs);
my $count    = @configs;
my $fhemhost = hostname;

## no critic
if ($count > 1) {
   foreach my $c (@configs) {
      next unless $c =~ m/^%dbconfig.*/;
      $dbconfig{fhemhost} = "";
      eval $c;
      last if ($dbconfig{fhemhost} eq $fhemhost);
   }
   eval $configs[0] if ($dbconfig{fhemhost} eq "");
} else {
   eval $configs[0];
}
## use critic

my $cfgDB_dbconn    = $dbconfig{connection};
my $cfgDB_dbuser    = $dbconfig{user};
my $cfgDB_dbpass    = $dbconfig{password};
my $cfgDB_dbtype;
my $cfgDB_filename;


if($cfgDB_dbconn =~ m/pg:/i) {
      $cfgDB_dbtype ="POSTGRESQL";
   } elsif ($cfgDB_dbconn =~ m/mysql:/i) {
      $cfgDB_dbtype = "MYSQL";
   } elsif ($cfgDB_dbconn =~ m/sqlite:/i) {
      $cfgDB_dbtype = "SQLITE";
      (undef,$cfgDB_filename) = split(/=/,$cfgDB_dbconn);
      $configDB{filename} = $cfgDB_filename;
   } else {
      $cfgDB_dbtype = "unknown";
}

$configDB{type}              = $cfgDB_dbtype;
$configDB{exclude}           = defined($dbconfig{exclude})     ? $dbconfig{exclude}     : '';
$configDB{attr}{nostate}     = defined($dbconfig{nostate})     ? $dbconfig{nostate}     : 0;
$configDB{attr}{rescue}      = defined($dbconfig{rescue})      ? $dbconfig{rescue}      : 0;
$configDB{attr}{loadversion} = defined($dbconfig{loadversion}) ? $dbconfig{loadversion} : 0;

_cfgDB_knownAttr();

%dbconfig = ();
@config   = ();
$configs  = undef;
$count    = undef;

##################################################
# Basic functions needed for DB configuration
# directly called from fhem.pl
#

# initialize database, create tables if necessary
sub cfgDB_Init {
##################################################
# Create non-existing database tables 
# Create default config entries if necessary
#
	my $fhem_dbh = _cfgDB_Connect;

#	create TABLE fhemversions ifnonexistent
	$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemversions(VERSION INT, VERSIONUUID CHAR(50), VERSIONTAG CHAR(50))");

#	create TABLE fhemconfig if nonexistent
	$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemconfig(COMMAND VARCHAR(32), DEVICE VARCHAR(64), P1 VARCHAR(64), P2 TEXT, VERSION INT, VERSIONUUID CHAR(50))");
	
#	create INDEX on fhemconfig if nonexistent (only if SQLITE)
	$fhem_dbh->do("CREATE INDEX IF NOT EXISTS config_idx on 'fhemconfig' (versionuuid,version)") 
	           if($cfgDB_dbtype eq "SQLITE");
		
#	check TABLE fhemconfig already populated
	my $count = $fhem_dbh->selectrow_array('SELECT count(*) FROM fhemconfig');
	if($count < 1) {
#		insert default entries to get fhem running
		$fhem_dbh->commit();
		my $uuid = createUniqueId();
		$fhem_dbh->do("INSERT INTO fhemversions values (0, '$uuid',NULL)");
		_cfgDB_InsertLine($fhem_dbh, $uuid, '#created by cfgDB_Init',0);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr global logdir ./log',1);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr global logfile %L/fhem-%Y-%m-%d.log',2);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr global modpath .',3);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr global userattr devStateIcon devStateStyle icon sortby webCmd',4);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr global verbose 3',5);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'define telnetPort telnet 7072 global',6);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'define web FHEMWEB 8083 global',7);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'attr web allowfrom .*',8);
		_cfgDB_InsertLine($fhem_dbh, $uuid, 'define Logfile FileLog %L/fhem-%Y-%m-%d.log Logfile',9);
	}

#	create TABLE fhemstate if nonexistent
	$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemstate(stateString TEXT)");

#	create TABLE fhemb64filesave if nonexistent
	if($cfgDB_dbtype eq "MYSQL") {
		$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemb64filesave(filename TEXT, content MEDIUMBLOB)");
	} elsif ($cfgDB_dbtype eq "POSTGRESQL") {
		$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemb64filesave(filename TEXT, content bytea)");
	} else {
		$fhem_dbh->do("CREATE TABLE IF NOT EXISTS fhemb64filesave(filename TEXT, content BLOB)");
	}

#   modify table for version tags if needed
    eval {$fhem_dbh->do("SELECT versiontag from fhemversions where version = 0")};
    $fhem_dbh->do("ALTER TABLE fhemversions ADD VERSIONTAG char(50)") if $@;

# close database connection
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();

	return;
}

# read attributes
sub cfgDB_AttrRead { 
	my ($readSpec) = @_;
	my ($row, $sql, @line, @rets);
	my $fhem_dbh = _cfgDB_Connect;
	my $uuid = $fhem_dbh->selectrow_array('SELECT versionuuid FROM fhemversions WHERE version = 0');
	$sql = "SELECT * FROM fhemconfig WHERE COMMAND = 'attr' AND DEVICE = '$readSpec' AND VERSIONUUID = '$uuid'";
	$sql = "SELECT * FROM fhemconfig WHERE COMMAND = 'attr' AND (DEVICE = 'global' OR DEVICE = 'configdb') and VERSIONUUID = '$uuid'" 
					if($readSpec eq 'global');  
	my $sth = $fhem_dbh->prepare( $sql );  
	$sth->execute();
	while (@line = $sth->fetchrow_array()) {
		if($line[1] eq 'configdb') {
           $configDB{attr}{$line[2]} = $line[3];
		} else {
			push @rets, "attr $line[1] $line[2] $line[3]";
		}
	}
	$fhem_dbh->disconnect();
	return @rets;
}

# generic file functions called from fhem.pl
sub cfgDB_FileRead {
	my ($filename,$fhem_dbh) = @_;
    my $internal_call = 1 if $fhem_dbh;

	Log 4, "configDB reading file: $filename";
	my ($err, @ret, $counter);
	$fhem_dbh = _cfgDB_Connect unless $fhem_dbh;
	my $read_cmd  = "SELECT content FROM fhemb64filesave WHERE filename = '$filename'";
	my $sth = $fhem_dbh->prepare( $read_cmd );
	$sth->execute();
	my $blobContent = $sth->fetchrow_array();
	$sth->finish();
	$fhem_dbh->disconnect() unless $internal_call;
	$blobContent = decode_base64($blobContent) if ($blobContent);
	$counter = length($blobContent);
	if($counter) {
		@ret = split(/\n/,$blobContent);
		$err = "";
	} else {
		@ret = undef;
		$err = "Error on reading $filename from database!";
	}
	return ($err, @ret);
}

sub cfgDB_FileWrite {
	my ($filename,@content) = @_;
	Log 4, "configDB writing file: $filename";
	my $fhem_dbh = _cfgDB_Connect;
	$fhem_dbh->do("delete from fhemb64filesave where filename = '$filename'");
	my $sth = $fhem_dbh->prepare('INSERT INTO fhemb64filesave values (?, ?)');
	$sth->execute($filename,encode_base64(join("\n", @content)));
	$sth->finish();
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();
	return;
}

sub cfgDB_FileUpdate {
	my ($filename) = @_;
	my $fhem_dbh = _cfgDB_Connect;
	my $id = $fhem_dbh->selectrow_array("SELECT filename from fhemb64filesave where filename = '$filename'");
	$fhem_dbh->disconnect();
	if($id) {
		my $filesize = -s $filename;
		_cfgDB_binFileimport($filename,$filesize,1) if ($id) ;
		Log 4, "file $filename updated in configDB";
	}
	return;
}

# read and execute fhemconfig and statefile
sub cfgDB_ReadAll {  ## prototype used in fhem.pl
	my ($cl) = @_;
	my ($ret, @dbconfig);

	if ($configDB{attr}{rescue} == 1) {
		Log 0, 'configDB starting in rescue mode!';
		push (@dbconfig, 'attr global modpath .');
		push (@dbconfig, 'attr global verbose 3');
		push (@dbconfig, 'define telnetPort telnet 7072 global');
		push (@dbconfig, 'define web FHEMWEB 8083 global');
		push (@dbconfig, 'attr web allowfrom .*');
		push (@dbconfig, 'define Logfile FileLog ./log/fhem-%Y-%m-%d.log Logfile');
	} else {
		# add Config Rows to commandfile
		@dbconfig = _cfgDB_ReadCfg(@dbconfig);
		# add State Rows to commandfile
		@dbconfig = _cfgDB_ReadState(@dbconfig) unless $configDB{attr}{nostate} == 1;
	}

	# AnalyzeCommandChain for all entries
	$ret = _cfgDB_Execute($cl, @dbconfig);
	return $ret if($ret);
	return;
}

# save running configuration to version 0
sub cfgDB_SaveCfg { ## prototype used in fhem.pl
    Log 4, "configDB save config ".$data{saveID} if(defined($data{saveID}));
	my ($internal) = shift;
	$internal = defined($internal) ? $internal : 0;
	my $c = "configdb";
	my @dontSave = qw(configdb:rescue configdb:nostate configdb:loadversion
	                  configdb:shortinfo 
	                  global:configfile global:statefile global:version);
	my (%devByNr, @rowList, %comments, $t, $out);

	map { $devByNr{$defs{$_}{NR}} = $_ } keys %defs;

	for(my $i = 0; $i < $devcount; $i++) {

		my ($h, $d);
		if($comments{$i}) {
			$h = $comments{$i};
		} else {
			$d = $devByNr{$i};
			next if(!defined($d) ||
				$defs{$d}{TEMPORARY} || # e.g. WEBPGM connections
				$defs{$d}{VOLATILE});   # e.g at, will be saved to the statefile
			$h = $defs{$d};
		}

		if(!defined($d)) {
			push @rowList, $h->{TEXT};
			next;
		}

		push (@rowList, GetDefAndAttr($d,1));

	}

		foreach my $a (sort keys %{$configDB{attr}}) {
			my $val = $configDB{attr}{$a};
			next unless $val;
			next if grep {$_ eq "$c:$a";} @dontSave;
			$val =~ s/;/;;/g;
			push @rowList, "attr $c $a $val";
		}

	$t = localtime;
	$out = "#created $t";
	push @rowList, $out;
    Debug "\n".join("\n",@rowList) if defined($data{cfgDB_debug});
    return @rowList if defined($data{cfgDB_rawList});

# Insert @rowList into database table
	my $fhem_dbh = _cfgDB_Connect;
	my ($num,$uuid) = split(/\:/,_cfgDB_Rotate($fhem_dbh,$internal));
	my $counter = 0;
	foreach (@rowList) { 
		_cfgDB_InsertLine($fhem_dbh, $uuid, $_, $counter); 
		$counter++;
	}
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();
	my $maxVersions = $configDB{attr}{maxversions};
	$maxVersions = ($maxVersions) ? $maxVersions : 0;
	_cfgDB_Reorg($maxVersions,1) if($maxVersions && $internal != -1);
	return "configDB saved. ($num)";
}

# save statefile
sub cfgDB_SaveState {
	my ($out,$val,$r,$rd,$t,@rowList);

    # don't write statefile in rescue mode
    return if ($configDB{attr}{rescue} == 1);

#    _cfgDB_deleteRF;

	$t = localtime;
	$out = "#$t";
	push @rowList, $out;

	foreach my $d (sort keys %defs) {
		next if($defs{$d}{TEMPORARY});
		if($defs{$d}{VOLATILE}) {
			$out = "define $d $defs{$d}{TYPE} $defs{$d}{DEF}";
			push @rowList, $out;
		}
		$val = $defs{$d}{STATE};
		if(defined($val) &&
			$val ne "unknown" &&
			$val ne "Initialized" &&
			$val ne "" &&
			$val ne "???") {
			$val =~ s/;/;;/g;
            $val =~ s/\n/\$xyz\$/g;
			$out = "setstate $d $val";
			Log 5, "configDB: $out";
			push @rowList, $out;
		}
		$r = $defs{$d}{READINGS};
		if($r) {
			foreach my $c (sort keys %{$r}) {
				$rd = $r->{$c};
				if(!defined($rd->{TIME})) {
					Log 5, "WriteStatefile $d $c: Missing TIME, using current time";
					$rd->{TIME} = TimeNow();
				}
				if(!defined($rd->{VAL})) {
					Log 5, "WriteStatefile $d $c: Missing VAL, setting it to 0";
					$rd->{VAL} = 0;
				}
				$val = $rd->{VAL};
				$val =~ s/;/;;/g;
                $val =~ s/\n/\$xyz\$/g;
				$out = "setstate $d $rd->{TIME} $c $val";
				Log 5, "configDB: $out"; 
                push @rowList, $out; 
			}
		}
	}

    my $fileName = defined($data{saveID}) ? $data{saveID} : $configDB{loaded};
       $fileName =~ s/^\s+|\s+$//g; # trim filename
       $fileName .= ".fhem.save";
    Log 4, "configDB save state $fileName with ".$#rowList." entries";
    cfgDB_FileWrite($fileName,@rowList);

	return;
}

# import existing files during migration 
sub cfgDB_MigrationImport {

	my ($ret, $filename, @files, @def);
	my $modpath = AttrVal("global","modpath",".");

# find eventTypes file
	@def = '';
	@def = _cfgDB_findDef('TYPE=eventTypes');
	foreach my $fn (@def) {
		next unless $fn;
		push @files, $fn;
	}

# import templateDB.gplot
	$filename = "$modpath/www/gplot/template.gplot";
	push @files, $filename;
	$filename = "$modpath/www/gplot/templateDB.gplot";
	push @files, $filename;

# import template.layout
	$filename = "$modpath/FHEM/template.layout";
	push @files, $filename;

# find used gplot files
	@def = '';
	@def = _cfgDB_findDef('TYPE=SVG','GPLOTFILE');
	foreach my $fn (@def) {
		next unless $fn;
		push @files, "$modpath/www/gplot/".$fn.".gplot";
	}

# find DbLog configs
	@def = '';
	@def = _cfgDB_findDef('TYPE=DbLog','CONFIGURATION');
	foreach my $fn (@def) {
		next unless $fn;
		push @files, $fn;
	}

# find RSS and Infopanel layouts
	@def = '';
	@def = _cfgDB_findDef('TYPE=(RSS|InfoPanel)','LAYOUTFILE');
	foreach my $fn (@def) {
		next unless $fn;
		push @files, $fn;
	}

# find weekprofile/LightScene/RHASSPY configurations
	@def = '';
	@def = _cfgDB_findDef('TYPE=(weekprofile|LightScene|RHASSPY)','CONFIGFILE');
	foreach my $fn (@def) {
		next unless $fn;
		push @files, $fn;
	}

# find holiday files
	@def = '';
	@def = _cfgDB_findDef('TYPE=holiday','NAME');
	foreach my $fn (@def) {
		next unless $fn;
		if(defined($defs{$fn}{HOLIDAYFILE})) {
           push @files, $defs{$fn}{HOLIDAYFILE};
		} else {
           push @files, "$modpath/FHEM/holiday/".$fn.".holiday";
		}
	}

# import uniqueID file
	$filename = "$modpath/FHEM/FhemUtils/uniqueID";
	push @files,$filename if (-e $filename);   

# do the import
	foreach my $fn (@files) {
		if ( -r $fn ) {
			my $filesize = -s $fn;
			_cfgDB_binFileimport($fn,$filesize);
			$ret .= "importing: $fn\n";
		}
	}

	return $ret;
}

# return SVN Id, called by fhem's CommandVersion
sub cfgDB_svnId { 
	return "# ".'$Id$' 
}

# return filelist depending on directory and regexp
sub cfgDB_FW_fileList {
	my ($dir,$re,@ret) = @_;
	my @files = split(/\n/, _cfgDB_Filelist('notitle'));
	foreach my $f (@files) {
		next if( $f !~ m/^$dir/ );
		$f =~ s,$dir\/,,;
		next if($f !~ m,^$re$, || $f eq '99_Utils.pm');
		push @ret, "$f.configDB";
	}
	return @ret;
}

# read filelist containing 99_ files in database
sub cfgDB_Read99 {
  my $ret = "";
  my $fhem_dbh = _cfgDB_Connect;
  my $sth = $fhem_dbh->prepare( "SELECT filename FROM fhemb64filesave WHERE filename like '%/99_%.pm' group by filename" );
  $sth->execute();
  while (my $line = $sth->fetchrow_array()) {
    $line =~ m,^(.*)/([^/]*)$,; # Split into dir and file
    $ret .= "$2,"; # 
  }
  $sth->finish();
  $fhem_dbh->disconnect();
  $ret =~ s/,$//;
  return $ret;
}

# return SVN Id from file stored in database
sub cfgDB_Fileversion {
  my ($file,$ret) = @_;
  $ret = "No Id found for $file";
  my ($err,@in) = cfgDB_FileRead($file);
  foreach(@in){ $ret = $_ if($_ =~ m/# \$Id:/); }
  return $ret;
}

##################################################
# Basic functions needed for DB configuration
# but not called from fhem.pl directly
#

# connect do database
sub _cfgDB_Connect {
	my $fhem_dbh = DBI->connect(
	"dbi:$cfgDB_dbconn", 
	$cfgDB_dbuser,
	$cfgDB_dbpass,
	{ AutoCommit => 0, RaiseError => 1 },
	) or die $DBI::errstr;
	return $fhem_dbh;
}

# add configuration entry into fhemconfig
sub _cfgDB_InsertLine {
	my ($fhem_dbh, $uuid, $line, $counter) = @_;
	Log 0, "configDB: $line" if defined($data{cfgDB_debug});
	my ($c,$d,$p1,$p2) = split(/ /, $line, 4);
	my $sth = $fhem_dbh->prepare('INSERT INTO fhemconfig values (?, ?, ?, ?, ?, ?)');
	$sth->execute($c, $d, $p1, $p2, $counter, $uuid);
	return;
}

# pass command table to AnalyzeCommandChain
sub _cfgDB_Execute {
	my ($cl, @dbconfig) = @_;
	my (@ret);

	foreach my $l (@dbconfig) {
		$l =~ s/[\r\n]/\n/g;
		$l =~ s/\\\n/\n/g;
		my $tret = AnalyzeCommandChain($cl, $l);
		push @ret, $tret if(defined($tret));
	}
	return join("\n", @ret) if(@ret);
	return;
}

# read all entries from fhemconfig
# and add them to command table for execution
sub _cfgDB_ReadCfg {
	my (@dbconfig) = @_;
	my $fhem_dbh = _cfgDB_Connect;
	my ($sth, @line, $row);

    my $version = $configDB{attr}{loadversion};
    delete $configDB{attr}{loadversion};
    if ($version > 0) {
       my $count = $fhem_dbh->selectrow_array('SELECT count(*) FROM fhemversions');
       $count--;
       $version = $version > $count ? $count : $version;
       Log 0, "configDB loading version $version on user request.";
    }    

# maybe this will be done with join later
	my $uuid = $fhem_dbh->selectrow_array("SELECT versionuuid FROM fhemversions WHERE version = '$version'");
	$uuid =~ s/^\s+|\s+$//g;
    $configDB{loaded} = $uuid;
    Log 4, "configDB read config ".$configDB{loaded};
    my @excluded = split(/,/,$configDB{exclude});
    map { s/^\s+|\s+$//g; } @excluded;
	$sth = $fhem_dbh->prepare( "SELECT * FROM fhemconfig WHERE versionuuid = '$uuid' and device <>'configdb' order by version" );  

	$sth->execute();
	while (@line = $sth->fetchrow_array()) {
		$row  = "$line[0] $line[1] $line[2]";
		$row .= " $line[3]" if defined($line[3]);
		if ( grep( /^$line[1]$/, @excluded ) ) {
		  Log 1, "configDB excluding $line[1] ($row)" if $line[0] eq "define";
		} else {
          push @dbconfig, $row;
		}
	}
	$fhem_dbh->disconnect();
	return @dbconfig;
}

# read all entries from fhemstate
# and add them to command table for execution
sub _cfgDB_ReadState {
	my (@dbconfig) = @_;

	my $stateFileName = $configDB{loaded}.".fhem.save";
    my ($err,@state) = cfgDB_FileRead($stateFileName);
    if ($err eq "") {
      Log 4, "configDB read state ".$stateFileName;
      map { my $a = $_; $a =~ s/\$xyz\$/\\n/g; push @dbconfig, $a } @state;
	  my $fhem_dbh = _cfgDB_Connect;
         $fhem_dbh->do("delete from fhemstate");
         $fhem_dbh->commit();
	     $fhem_dbh->disconnect();
    } else {
      Log 4, "configDB read state from table fhemstate";
	  my $fhem_dbh = _cfgDB_Connect;
	  my ($sth, $row,$f);
	  $sth = $fhem_dbh->prepare( "SELECT * FROM fhemstate" );  
	  $sth->execute();
	  while ($row = $sth->fetchrow_array()) {
	    if($row =~ m/(cfgDBkey:)(.{32})/) {
          my $f = $2;
	       my (undef, $content) = cfgDB_FileRead($f,$fhem_dbh);
	       $row =~ s/cfgDB:................................$/$content/;
	       _cfgDB_Filedelete($f,$fhem_dbh);
        }
		push @dbconfig, $row;
	  }
	  $fhem_dbh->disconnect();
    }
	return @dbconfig;
}

# rotate all versions to versionnum + 1
# return uuid for new version 0
sub _cfgDB_Rotate {
	my ($fhem_dbh,$newversion) = @_;
    my $uuid = $data{saveID};
       $uuid =~ s/^\s+|\s+$//g;
    delete $data{saveID}; # no longer needed in memory
	$configDB{loaded} = $uuid;
	my $count = $fhem_dbh->do("UPDATE fhemversions SET VERSION = VERSION+1 where VERSION >= 0") if $newversion == 0;
	$fhem_dbh->do("INSERT INTO fhemversions values ('$newversion', '$uuid', NULL)");
	Log3(undef,1,"configDB: more than 20 versions in database! Please consider setting a limit.") 
	    if ($count > 20 && !defined($configDB{attr}{maxversions}));
	return "$count:$uuid";
}

sub _cfgDB_filesize_str {
    my ($size) = @_;

    if ($size > 1099511627776)  #   TiB: 1024 GiB
    {
        return sprintf("%.2f TB", $size / 1099511627776);
    }
    elsif ($size > 1073741824)  #   GiB: 1024 MiB
    {
        return sprintf("%.2f GB", $size / 1073741824);
    }
    elsif ($size > 1048576)     #   MiB: 1024 KiB
    {
        return sprintf("%.2f MB", $size / 1048576);
    }
    elsif ($size > 1024)        #   KiB: 1024 B
    {
        return sprintf("%.2f KB", $size / 1024);
    }
    else                        #   bytes
    {
        return "$size byte" . ($size == 1 ? "" : "s");
    }
}

##################################################
# Additional backend functions
# not called from fhem.pl directly
#

# migrate existing fhem config into database
sub _cfgDB_Migrate {
	my $ret;
	$data{saveID} = createUniqueId();
	$ret = "Starting migration...\n";
	Log 4, 'configDB: Starting migration';
	$ret .= "Processing: database initialization\n";
	Log 4, 'configDB: Processing: cfgDB_Init';
	cfgDB_Init;
	$ret .= "Processing: save config\n";
	Log 4, 'configDB: Processing: cfgDB_SaveCfg';
	cfgDB_SaveCfg;
	$ret .= "Processing: save state\n";
	Log 4, 'configDB: Processing: cfgDB_SaveState';
	cfgDB_SaveState;
	$ret .= "Processing: fileimport\n";
	Log 4, 'configDB: Processing: cfgDB_MigrationImport';
	$ret .= cfgDB_MigrationImport;
	$ret .= "Migration completed\n\n";
	Log 4, 'configDB: Migration completed.';
	$ret .= _cfgDB_Info(undef);
	return $ret;
}

# show database statistics
sub _cfgDB_Info {
	my ($info2,$raw) = @_;
	$info2 //= 'unknown';
	$raw //= 0;
	my ($l, @r, $f);
	for my $i (1..65){ $l .= '-';}

    $configDB{attr}{private} //= 1;

	push @r, $l;
	push @r, " configDB Database Information";
	push @r, $l;
	my $info1 = cfgDB_svnId;
	$info1 =~ s/# //;
	push @r, " d:$info1";
	push @r, " c:$info2";
	push @r, $l;
	push @r, " dbconn: $cfgDB_dbconn";
	push @r, " dbuser: $cfgDB_dbuser" if !$configDB{attr}{private};
	push @r, " dbpass: $cfgDB_dbpass" if !$configDB{attr}{private};
	push @r, " dbtype: $cfgDB_dbtype";
	push @r, " Unknown dbmodel type in configuration file." if $cfgDB_dbtype eq 'unknown';
	push @r, " Only Mysql, Postgresql, SQLite are fully supported." if $cfgDB_dbtype eq 'unknown';
	if ($cfgDB_dbtype eq "SQLITE") {
	    my $size = -s $cfgDB_filename;
	    $size = _cfgDB_filesize_str($size);
		push @r, " dbsize: $size";
	}
	push @r, $l;
	push @r, " loaded:       ".$configDB{loaded};
	my $fhem_dbh = _cfgDB_Connect;
	my ($sql, $sth, @line, $row, $countDef, $countAttr, @raw);

# read versions table statistics

    $configDB{attr}{shortinfo} //= 0;
    if ($configDB{attr}{shortinfo} == 0) {
		my $maxVersions = $configDB{attr}{maxversions};
		$maxVersions = ($maxVersions) ? $maxVersions : 0;
		push @r, " max Versions: $maxVersions" if($maxVersions);
		push @r, " lastReorg:    ".$configDB{attr}{'lastReorg'};
		my $count;
		$count = $fhem_dbh->selectrow_array('SELECT count(*) FROM fhemconfig');
		push @r, " config:       $count entries";
		push @r, "";

		# read versions creation time
		$sql = "SELECT * FROM fhemconfig as c join fhemversions as v on v.versionuuid=c.versionuuid ".
				"WHERE COMMAND like '#created%' ORDER by v.VERSION";
		$sth = $fhem_dbh->prepare( $sql );
		$sth->execute();
		while (@line = $sth->fetchrow_array()) {
			$line[3]   = "" unless defined $line[3];
			$countDef  = $fhem_dbh->selectrow_array("SELECT COUNT(*) from fhemconfig where COMMAND = 'define' and VERSIONUUID = '$line[5]'");
			$countAttr = $fhem_dbh->selectrow_array("SELECT COUNT(*) from fhemconfig where COMMAND = 'attr' and VERSIONUUID = '$line[5]'");
			$row  = " Ver $line[6] saved: $line[1] $line[2] $line[3] def: $countDef attr: $countAttr";
			$row .= " tag: ".$line[8] if $line[8];
			push @r, $row;
			push @raw, {version => $line[6], saved => "$line[1] $line[2] $line[3]", def => $countDef, attr => $countAttr};
		}
    } else {
    	my $count;
    	$count = $fhem_dbh->selectrow_array('SELECT count(*) FROM fhemversions');
    	push @r, " versions:     $count";
		$count = $fhem_dbh->selectrow_array('SELECT count(*) FROM fhemconfig');
		push @r, " config:       $count entries";
    }
	push @r, $l;

	$row = $fhem_dbh->selectall_arrayref("SELECT filename from fhemb64filesave group by filename");
	$count = @$row;
	$count = ($count)?$count:'No';
	$f = ("$count" ne '1') ? "s" : "";
	$row = " filesave: $count file$f stored in database";
	push @r, $row;
	push @r, $l;
	$fhem_dbh->disconnect();

	return toJSON \@raw if $raw;
	return join("\n", @r);
}

sub _cfgDB_Info_Json {
  my $cSVN = shift;
  $cSVN //= 'unknown';
  my %info = ();

# add ./FHEM/98_configdb.pm svn id
  $info{cSVN} = $cSVN;

# add ./configDB.pm svn id
  my $dSVN = cfgDB_svnId;
  $dSVN =~ s/# //;
  $info{dSVN} = $dSVN;

# add configDB database info
	$info{dbconn} = $cfgDB_dbconn;
	$info{dbuser} = $configDB{attr}{private} ? 'private' : $cfgDB_dbuser;
	$info{dbpass} = $configDB{attr}{private} ? 'private' : $cfgDB_dbpass;
	$info{dbtype} = $cfgDB_dbtype;
    $info{dbsize} = _cfgDB_filesize_str(-s $cfgDB_filename) if ($cfgDB_dbtype eq "SQLITE");
    
  return toJSON \%info;
}

# recover former config from database archive
sub _cfgDB_Recover {
	my ($version) = @_;
	my ($cmd, $count, $ret);

	if($version > 0) {
		my $fhem_dbh = _cfgDB_Connect;
		$cmd = "SELECT count(*) FROM fhemconfig WHERE VERSIONUUID in (select versionuuid from fhemversions where version = $version)";
		$count = $fhem_dbh->selectrow_array($cmd);

		if($count > 0) {
			my $fromuuid = $fhem_dbh->selectrow_array("select versionuuid from fhemversions where version = $version");
			my $touuid   = createUniqueId();
#			Delete current version 0
			$fhem_dbh->do("DELETE FROM fhemconfig WHERE VERSIONUUID in (select versionuuid from fhemversions where version = 0)");
			$fhem_dbh->do("update fhemversions set versionuuid = '$touuid' where version = 0");

#			Copy selected version to version 0
			my ($sth, $sth2, @line);
			$cmd = "SELECT * FROM fhemconfig WHERE VERSIONUUID = '$fromuuid'";
			$sth = $fhem_dbh->prepare($cmd);  
			$sth->execute();
			$sth2 = $fhem_dbh->prepare('INSERT INTO fhemconfig values (?, ?, ?, ?, ?, ?)');
			while (@line = $sth->fetchrow_array()) {
				$sth2->execute($line[0], $line[1], $line[2], $line[3], $line[4], $touuid);
			}
			$fhem_dbh->commit();
			$fhem_dbh->disconnect();

#           Copy corresponding statefile
            my $filename  = $fromuuid.".fhem.save";
            my ($err,@statefile) = FileRead($filename);
            $filename = $touuid.".fhem.save";
            FileWrite($filename,@statefile);

#			Inform user about restart required
			$ret  = "Version 0 deleted.\n";
			$ret .= "Version $version copied to version 0\n\n";
            $ret .= "FHEM will exit in 3 seconds.";
            InternalTimer(gettimeofday()+3, sub {exit 0}, 0);
		} else {
			$fhem_dbh->disconnect();
			$ret = "No entries found in version $version.\nNo changes committed to database.";
		}
	} else {
		$ret = 'Please select version 1..n for recovery.';
	}
	return $ret;
}

# delete old configurations
sub _cfgDB_Reorg {
	my ($lastversion,$quiet) = @_;
	$lastversion = (defined($lastversion)) ? $lastversion : 3;
	Log 4, "configDB reorg started, keeping last $lastversion versions.";
	my $fhem_dbh = _cfgDB_Connect;
	$fhem_dbh->do("delete FROM fhemconfig   where versionuuid in (select versionuuid from fhemversions where version > $lastversion)");
	$fhem_dbh->do("delete from fhemversions where version > $lastversion");
	$fhem_dbh->do("delete FROM fhemconfig   where versionuuid in (select versionuuid from fhemversions where version = -1)");
	$fhem_dbh->do("delete from fhemversions where version = -1");
	my $ts = localtime(time);
	$configDB{attr}{'lastReorg'} = $ts;
	_cfgDB_InsertLine($fhem_dbh,$configDB{loaded},"attr configdb lastReorg $ts",-1); 
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();
	_cfgDB_deleteStatefiles();
	eval { qx(sqlite3 $cfgDB_filename vacuum) } if($cfgDB_dbtype eq "SQLITE");
	return if(defined($quiet));
	return " Result after database reorg:\n"._cfgDB_Info(undef);
}

# delete temporary version
sub _cfgDB_DeleteTemp {
	Log 4, "configDB: delete temporary Version -1";
	my $fhem_dbh = _cfgDB_Connect;
	$fhem_dbh->do("delete FROM fhemconfig   where versionuuid in (select versionuuid from fhemversions where version = -1)");
	$fhem_dbh->do("delete from fhemversions where version = -1");
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();
	return;
}

# search for device or fulltext in db
sub _cfgDB_Search {
	my ($search,$searchversion,$dsearch) = @_;
	return 'Syntax error.' if(!(defined($search)));
	my $fhem_dbh = _cfgDB_Connect;
	my ($sql, $sth, @line, $row, @result, $ret, $text);
	$sql  = "SELECT command, device, p1, p2 FROM fhemconfig as c join fhemversions as v ON v.versionuuid=c.versionuuid ";
	$sql .= "WHERE v.version = '$searchversion' AND command not like '#create%' ";
	# 2015-10-24 - changed, forum #42190
	if($cfgDB_dbtype eq 'SQLITE') {;
		$sql .= "AND device like '$search%' ESCAPE '\\' " if($dsearch);
		$sql .= "AND (device like '$search%' ESCAPE '\\' OR P1 like '$search%' ESCAPE '\\' OR P2 like '$search%' ESCAPE '\\') " if(!$dsearch);
	} else {
		$sql .= "AND device like '$search%' " if($dsearch);
		$sql .= "AND (device like '$search%' OR P1 like '$search%' OR P2 like '$search%') " if(!$dsearch);
	}
	$sql .= "ORDER BY lower(device),command DESC";
	$sth = $fhem_dbh->prepare( $sql);
	Log 4, "configDB: $sql";
	$sth->execute();
	$text = $dsearch ? " device" : "";
	push @result, "search result for$text: $search in version: $searchversion";
	push @result, "--------------------------------------------------------------------------------";
	while (@line = $sth->fetchrow_array()) {
		$row  = "$line[0] $line[1] $line[2]";
        $row .= " $line[3]" if defined($line[3]);
		Log 4, "configDB: $row";
		push @result, "$row" unless ($line[0] eq 'setuuid');
	}
	$fhem_dbh->disconnect();
	$ret = join("\n", @result);
	return $ret;
}

# called from cfgDB_Diff
sub __cfgDB_Diff {
	my ($fhem_dbh,$search,$searchversion,$svinternal) = @_;
	my ($sql, $sth, @line, $ret);
if($svinternal != -1) {
	$sql =	"SELECT command, device, p1, p2 FROM fhemconfig as c join fhemversions as v ON v.versionuuid=c.versionuuid ".
					"WHERE v.version = '$searchversion' AND device = '$search' ORDER BY command DESC";
} else {
	$sql =	"SELECT command, device, p1, p2 FROM fhemconfig as c join fhemversions as v ON v.versionuuid=c.versionuuid ".
					"WHERE v.version = '$searchversion' ORDER BY command DESC";
}
	$sth = $fhem_dbh->prepare( $sql);
	$sth->execute();
	while (@line = $sth->fetchrow_array()) {
	    $line[3] //= "";
		$ret .= "$line[0] $line[1] $line[2] $line[3]\n";
	}
	return $ret;
}

# compare device configurations from 2 versions
sub _cfgDB_Diff {
	my ($search,$searchversion) = @_;
	my ($ret, $v0, $v1);

	if ($search eq 'all' && $searchversion eq 'current') {
		_cfgDB_DeleteTemp();
		cfgDB_SaveCfg(-1);
		$searchversion = -1;
	}

	my $fhem_dbh = _cfgDB_Connect;
		$v0 = __cfgDB_Diff($fhem_dbh,$search,0,$searchversion);
		$v1 = __cfgDB_Diff($fhem_dbh,$search,$searchversion,$searchversion);
	$fhem_dbh->disconnect();
	$ret = diff \$v0, \$v1, { STYLE => "Table" };
	if($searchversion == -1) {
		_cfgDB_DeleteTemp();
		$searchversion = "UNSAVED";
	}
	$ret = "\nNo differences found!" if !$ret;
	$ret = "compare device: $search in current version 0 (left) to version: $searchversion (right)\n$ret\n";
	return $ret;
}

# find DEF, input supports devspec definitions
sub _cfgDB_findDef {
	my ($search,$internal) = @_;
	$internal = 'DEF' unless defined($internal);

	my @ret;
	my @etDev = devspec2array($search);
	foreach my $d (@etDev) {
		next unless $d;
		push @ret, $defs{$d}{$internal};
	}

	return @ret;
}

sub _cfgDB_type { 
   return $cfgDB_dbtype;
}

sub _cfgDB_dump {
   my ($param1) = @_;
   $param1 //= '';

   my ($dbconn,$dbuser,$dbpass,$dbtype)  = _cfgDB_readConfig();
   my ($dbname,$dbhostname,$dbport,$gzip,$mp,$ret,$size,$source,$target,$ts);
   $ts     = strftime('%Y-%m-%d_%H-%M-%S',localtime);
   $mp     = $configDB{attr}{'dumpPath'};
   $mp   //= AttrVal('global','modpath','.').'/log';
   $target = "$mp/configDB_$ts.dump";

   if (lc($param1) eq 'unzipped') {
      $gzip = '';
   } else {
      $gzip    = '| gzip -c';
      $target .= '.gz';
   }

   if ($dbtype eq 'SQLITE') {
      (undef,$source) = split (/=/, $dbconn);
      my $dumpcmd = "echo '.dump fhem%' | sqlite3 $source $gzip > $target";
      Log 4, "configDB: $dumpcmd";
      $ret        = qx($dumpcmd);
      return $ret if $ret; # return error message if available

   } elsif ($dbtype eq 'MYSQL') {
      ($dbname,$dbhostname,$dbport) = split (/;/,$dbconn);
      $dbport //= '=3306';
      (undef,$dbname)     = split (/=/,$dbname);
      (undef,$dbhostname) = split (/=/,$dbhostname);
      (undef,$dbport)     = split (/=/,$dbport);
      my $xparam = defined($configDB{attr}{mysqldump}) ? $configDB{attr}{mysqldump} : '';
      my $dbtables = "fhemversions fhemconfig fhemstate fhemb64filesave";
      my $dumpcmd = "mysqldump $xparam --user=$dbuser --password=$dbpass --host=$dbhostname --port=$dbport -Q $dbname $dbtables $gzip > $target";
      Log 4, "configDB: $dumpcmd";
      $ret        = qx($dumpcmd);
      return $ret if $ret;
      $source = $dbname;

   } elsif ($dbtype eq 'POSTGRESQL') {
      ($dbname,$dbhostname,$dbport) = split (/;/,$dbconn);
      $dbport //= '=5432';
      (undef,$dbname)     = split (/=/,$dbname);
      (undef,$dbhostname) = split (/=/,$dbhostname);
      (undef,$dbport)     = split (/=/,$dbport);
      my $dbtables = "-t fhemversions -t fhemconfig -t fhemstate -t fhemb64filesave";
      my $dumpcmd = "PGPASSWORD=$dbpass pg_dump -U $dbuser -h $dbhostname -p $dbport $dbname $dbtables $gzip > $target";
      Log 4, "configDB: $dumpcmd";
      $ret        = qx($dumpcmd);
      return $ret if $ret;
      $source     = $dbname;

   } else {
      return "configdb dump not supported for $dbtype!";
   }

   $size = -s $target;
   $size //= 0;
   $ret  = "configDB dumped $size bytes\nfrom: $source\n  to: $target";
   return $ret;

}

sub _cfgDB_knownAttr {
  $configDB{knownAttr}{deleteimported} =
    "(0|1) delete file from filesystem after import";
  $configDB{knownAttr}{dumpPath} =
    "(valid path) define path for database dump";
  $configDB{knownAttr}{maxversions}=
    "(number) define maximum number of configurations stored in database";
  $configDB{knownAttr}{mysqldump}=
    "(valid parameter string) define additional parameters used for dump in mysql environment";
  $configDB{knownAttr}{private}=
    "(0|1) show or supress userdata in info output";
  $configDB{knownAttr}{shortinfo}=
    "(0|1) show detailed or short result in info output";
#  $configDB{knownAttr}{loadversion}=
#    "for internal use only";
#  $configDB{knownAttr}{nostate}=
#    "for internal use only";
#  $configDB{knownAttr}{rescue}=
#    "for internal use only";
}

sub _cfgDB_deleteRF {
# Delete old files containing large readings
  my $filename;
   my $fhem_dbh2 = _cfgDB_Connect;
   my $sth = $fhem_dbh2->prepare( "SELECT filename FROM fhemb64filesave" );  
   $sth->execute();
   while ($filename = $sth->fetchrow_array()) {
     if ($filename =~ m/^[0-9A-F]+$/i) {
       Log 4, "configDB delete file: $filename";
       $fhem_dbh2->do("delete from fhemb64filesave where filename = '$filename'");
     }
   }
   $fhem_dbh2->commit();
   $fhem_dbh2->disconnect();
}

sub _cfgDB_deleteStatefiles {
   my $filename;
   my $fhem_dbh = _cfgDB_Connect;
   my $sth = $fhem_dbh->prepare( "SELECT filename FROM fhemb64filesave where filename like '%.fhem.save'" );  
   $sth->execute();
   while ($filename = $sth->fetchrow_array()) {
       Log 5, "configDB: statefile  filename >$filename<";
       if (length($filename) > 42) { # malformed filename from postgresql
         Log 5, "configDB: statefile del1 >$filename<";
         $fhem_dbh->do("delete from fhemb64filesave where filename = '$filename'");
         next;       
       }
       my $uuid  = "";
       $uuid = substr($filename,0,32);
       Log 5, "configDB: statefile uuid:  >$uuid<";
       my $found = $fhem_dbh->selectrow_array("SELECT versionuuid FROM fhemversions WHERE versionuuid = '$uuid'");
       $found //= 'notfound'; # to prevent perl warning
       $found = substr($found,0,32);
       Log 5, "configDB: statefile found: >$found<";
       unless ($uuid eq $found) {
         Log 5, "configDB: statefile del2 >$filename<";
         $fhem_dbh->do("delete from fhemb64filesave where filename = '$filename'");
       }
   }
   $fhem_dbh->commit();
   $fhem_dbh->disconnect();
}

##################################################
# functions used for file handling
# called by 98_configdb.pm
#

# delete file from database
sub _cfgDB_Filedelete {
	my ($filename,$fhem_dbh) = @_;
	my $internal_call = 1 if $fhem_dbh;
	$fhem_dbh = _cfgDB_Connect unless $internal_call;
	my $ret = $fhem_dbh->do("delete from fhemb64filesave where filename = '$filename'");
	$fhem_dbh->commit();
	$fhem_dbh->disconnect() unless $internal_call;
	$ret = ($ret > 0) ? 1 : undef;
	return $ret;
}

# export file from database to filesystem
sub _cfgDB_Fileexport {
	my ($filename,$raw) = @_;
	my $fhem_dbh = _cfgDB_Connect;
	my $sth      = $fhem_dbh->prepare( "SELECT content FROM fhemb64filesave WHERE filename = '$filename'" );  
	$sth->execute();
	my $blobContent = $sth->fetchrow_array();
    $blobContent = decode_base64($blobContent) if($blobContent);
	my $counter = length($blobContent);
	$sth->finish();
	$fhem_dbh->disconnect();
	return "No data found for file $filename" unless $counter;
	return ($blobContent,$counter) if $raw;
	
	open( my $f,">","$filename" );
		binmode($f);
		print $f $blobContent;
	close( $f );
	return "$counter bytes written from database into file $filename";
}

# import file into database
sub _cfgDB_binFileimport {
	my ($filename,$filesize,$doDelete) = @_;
	$doDelete = (defined($doDelete)) ? 1 : 0;

	open (my $inFile,"<","$filename") || die $!;
		my $blobContent;
		binmode($inFile);
		my $readBytes = read($inFile, $blobContent, $filesize);
	close($inFile);
	$blobContent = encode_base64($blobContent);
	my $fhem_dbh = _cfgDB_Connect;
	$fhem_dbh->do("delete from fhemb64filesave where filename = '$filename'");
	my $sth = $fhem_dbh->prepare('INSERT INTO fhemb64filesave values (?, ?)');

# add support for postgresql by Matze
    $sth->bind_param( 1, $filename );
    if ($cfgDB_dbtype eq "POSTGRESQL") {
        $sth->bind_param( 2, $blobContent, { pg_type => DBD::Pg::PG_BYTEA() } );
    } else {
        $sth->bind_param( 2, $blobContent );
    }

	$sth->execute($filename, $blobContent);
	$sth->finish();
	$fhem_dbh->commit();
	$fhem_dbh->disconnect();

	unlink($filename) if(($configDB{attr}{deleteimported} || $doDelete) && $readBytes);
	return "$readBytes bytes written from file $filename to database";
}

# list all files stored in database
sub _cfgDB_Filelist {
	my ($notitle) = @_;
	my $ret =	"Files found in database:\n".
				"------------------------------------------------------------\n";
	$ret = "" if $notitle;
	my $fhem_dbh = _cfgDB_Connect;
	my $sql = "SELECT filename FROM fhemb64filesave group by filename order by filename";  
	my $content = $fhem_dbh->selectall_arrayref($sql);
	foreach my $row (@$content) {
		$ret .= "@$row[0]\n" if(defined(@$row[0]));
	}
	$fhem_dbh->disconnect();
	return $ret;
}

1;

=pod
=item helper
=item summary    configDB backend
=item summary_DE configDB backend
=begin html

<a name="configDB"></a>
<h3>configDB</h3>
	<ul>
	<a href="https://forum.fhem.de/index.php?board=46.0">Link to FHEM forum</a><br/><br/>
	This is the core backend library for configuration from SQL database.<br/>
	See <a href="#configdb">configdb command documentation</a> for detailed info.<br/>
	</ul>

=end html

=begin html_DE

<a name="configDB"></a>
<h3>configDB</h3>
	<ul>
	configDB ist die Funktionsbibliothek f&uuml;r die Konfiguration aus einer SQL Datenbank.<br/>
	Die ausf&uuml;hrliche Dokumentation findet sich in der <a href="#configdb">configdb Befehlsbeschreibung</a>.
	</ul>

=end html_DE

=cut