package MySQL::Keeper;
use strict;
use warnings 'all';
use base qw(Contenido::Keeper);
use locale;
use Data::Dumper;
use DBI;
use DBD::mysql;
use IO::File;
use File::Copy;
use Image::Size;
use Contenido::Globals;
use MySQL::Globals;
# ------------------------------------------------------------------------------------------------
# Конструктор объекта базы данных.
# Обязательный параметр - объект класса Contenido::State из которого
# конструктор возьмет необходимые параметры для доступа к БД и т.д.
#
# Формат вызова:
# MySQL::Keeper->new($state)
# ------------------------------------------------------------------------------------------------
sub new
{
my ($proto, $state) = @_;
die "Contenido Die: Неправильный вызов конструктора объекта базы данных. В параметрах нет объекта класса MySQL::State\n" unless ref($mstate);
my $class = ref($proto) || $proto;
my $self = {};
bless($self, $class);
# Заполним собственные свойства конкретными данными...
$self->{db_type} = 'remote';
$self->{db_keepalive} = 1;
$self->{db_host} = $state->db_host();
$self->{db_name} = $state->db_name();
$self->{db_user} = $state->db_user();
$self->{db_password} = $state->db_password();
$self->{db_port} = $state->db_port();
# $self->{data_dir} = $self->{data_directory} = $state->data_directory();
# $self->{images_dir} = $self->{images_directory} = $state->images_directory();
# $self->{binary_dir} = $self->{binary_directory} = $state->binary_directory();
# $self->{debug} = $state->debug();
# $self->{store_method} = $state->store_method();
# $self->{cascade} = $state->cascade();
$self->{state} = $state;
$self->_init_();
# соединяемся с базой если используется постоянное соединение
$self->connect();
return $self;
}
# МЕТОДЫ ДОСТУПА К СОЕДИНЕНИЯМ С БАЗОЙ УМНЫЕ
# получение соединения с базой или установка нового если его не было
sub SQL {
my $self = shift;
return ($self->connect_check() ? $self->{SQL} : undef);
}
# -------------------------------------------------------------------------------------------------
# Открываем соединение с базой данных
# -------------------------------------------------------------------------------------------------
sub connect {
my $self = shift;
#соединение уже есть
if ($self->is_connected) {
} else {
unless ($self->{SQL} = $self->db_connect) {
warn "Не могу соединиться с базой данных";
die;
}
$self->{SQL}->do("SET NAMES '".$self->state->db_client_encoding."'") if ($self->state->db_client_encoding);
}
$self->{_connect_ok} = 1;
return 1;
}
#проверка соединения с базой кеширующая состояние соединения
sub connect_check {
my $self = shift;
return 1 if ($self->{_connect_ok});
if ($self->is_connected) {
$self->{_connect_ok} = 1;
return 1;
} else {
if ($self->connect) {
return 1;
} else {
#сюда по логике попадать не должно так как die вылететь должен
warn "Connect failed\n";
return 0;
}
}
}
sub db_connect {
my $self = shift;
my $dbh = DBI->connect("DBI:mysql:database=".$self->{db_name}.";host=".$self->{db_host}, $self->{db_user}, $self->{db_password})
|| die "Contenido Error: Не могу соединиться с MySQL базой данных\n";
$dbh->{'AutoCommit'} = 1;
$dbh->{mysql_auto_reconnect} = 1;
return $dbh;
}
sub is_connected {
my $self = shift;
if (ref($self->{SQL}) and $self->{SQL}->can('ping') and $self->{SQL}->ping()) {
$self->{_connect_ok} = 1;
return 1;
} else {
$self->{_connect_ok} = 0;
return 0;
}
# warn 'Check if MySQL DB connected: '.(ref $self && exists $self->{SQL} && ref $self->{SQL} ? 1 : 0 ) if $DEBUG;
# return ( ref($self) && exists $self->{SQL} && ref $self->{SQL} );
}
# -------------------------------------------------------------------------------------------------
# Закрываем соединение с базой данных
# -------------------------------------------------------------------------------------------------
sub shutdown
{
my $self = shift;
$self->{SQL}->disconnect() if ref $self->{SQL};
delete $self->{SQL};
warn "SQL= ".(exists $self->{SQL} && ref $self->{SQL} ? 1 : 0) if $DEBUG;
warn "Contenido Debug: Закрыто соединение с базой данных MySQL на порту ".$self->{db_port}." keepalive=".$mstate->db_keepalive." .\n" if ($self->{debug});
}
# ----------------------------------------------------------------------------
# Инициализация.
# - Создает внутри объекта хэш с типами полей - это нужно для быстрой
# работы метода AUTOLOAD...
# ----------------------------------------------------------------------------
sub _init_
{
my $self = shift;
foreach my $attribute ( qw(
db_host db_name db_user db_password db_port
db_type db_keepalive
default_status
debug
state
SQL) )
{
$self->{attributes}->{ $attribute } = 'SCALAR';
}
}
# ----------------------------------------------------------------------------
# Функции работы с данными:
#
# >> get_object
# table => название таблицы
# fields => [fieldname, fieldname, ..., fieldname]
# wheres => список ограничений
# wheres => 'condition'
# wheres => ['condition 1', 'condition 2']
# wheres => { field1 => 'value1', field2 => 'value2' }
# values => список значений для wheres с передачей списка
# limit => Limit
# offset => Offset
# order_by=> Сортировка
# id => По ID
# count => Just count
#
# ----------------------------------------------------------------------------
sub get_object {
my $self = shift;
my %opts = @_;
return undef unless $opts{table};
my $ret_value = [];
my $request = "SELECT ";
if ( exists $opts{count} && $opts{count} ) {
$request .= 'COUNT(*) AS cid ';
} else {
$request .= ( exists $opts{fields} && ref $opts{fields} eq 'ARRAY' ? join(', ',@{$opts{fields}}) : '*' );
}
my (@wheres, @values);
$request .= " FROM $opts{table}";
if ( exists $opts{id} && $opts{id} ) {
if (ref $opts{id} eq 'ARRAY') {
@wheres = ( "id IN (".join(',', map { '?' } @{$opts{id}} ).")" );
@values = @{ $opts{id} };
} else {
@wheres = ( "id = ?" );
@values = ( $opts{id} );
}
}
if ( exists $opts{wheres} && $opts{wheres} ) {
if ( ref $opts{wheres} eq 'ARRAY' ) {
push @wheres, @{ $opts{wheres} };
if ( exists $opts{values} && $opts{values} ) {
if ( exists $opts{values} && ref $opts{values} eq 'ARRAY' && @{ $opts{values} } ) {
push @values, @{ $opts{values} };
} elsif ( !ref $opts{values} ) {
push @values, $opts{values};
}
}
} elsif ( ref $opts{wheres} eq 'HASH' ) {
while ( my ($field, $value) = each %{ $opts{wheres} } ) {
push @wheres, "$field = ?";
push @values, $value;
}
} else {
push @wheres, $opts{wheres};
if ( exists $opts{values} && $opts{values} ) {
if ( exists $opts{values} && ref $opts{values} eq 'ARRAY' && @{ $opts{values} } ) {
push @values, @{ $opts{values} };
} elsif ( !ref $opts{values} ) {
push @values, $opts{values};
}
}
}
}
if ( @wheres ) {
$request .= ' WHERE '.join( ' and ', map { "($_)" } @wheres );
}
if ( $opts{order_by} ) {
$request .= " ORDER BY $opts{order_by}";
}
if ( $opts{limit} ) {
$request .= " LIMIT $opts{limit}";
}
if ( $opts{offset} ) {
$request .= " OFFSET $opts{offset}";
}
warn $request if $DEBUG;
warn "Values: [".join(',', map { defined $_ ? $_ : 'NULL' } @values )."]\n" if $DEBUG && @values;
my $dbh = $self->SQL;
my $result = $dbh->prepare($request);
my $res = $result->execute( @values );
unless ( $res ) {
warn $dbh->errstr;
warn "QUERY: [$request]\n";
warn "OPTS: [".Dumper(\%opts)."]\n";
return undef;
}
if ( $opts{count} ) {
my $ln = $result->fetchrow_hashref();
return $ln->{cid};
}
while ( my $ln = $result->fetchrow_hashref() ) {
push @$ret_value, $ln;
}
if ( $opts{id} && ref $opts{id} ne 'ARRAY' && ref $ret_value eq 'ARRAY' && scalar @$ret_value) {
$ret_value = $ret_value->[0];
} elsif ( $opts{id} && ref $opts{id} eq 'ARRAY' && ref $ret_value eq 'ARRAY' && scalar @$ret_value) {
} elsif ( $opts{id} ) {
return undef;
} elsif ( ref $ret_value ne 'ARRAY' ) {
return undef;
}
$result->finish;
return $ret_value;
}
# ---------------------------------------------------------------------------
# Получить следующий ID в объекте
# >> get_next_id
# table => название таблицы
#
# ----------------------------------------------------------------------------
sub get_next_id {
my $self = shift;
my $tablename = shift;
return unless $tablename;
my $request = "SELECT MAX(id)+1 FROM $tablename";
my $dbh = $self->SQL;
my $result = $dbh->prepare($request);
$result->execute();
my $ln = $result->fetchrow();
$result->finish;
return $ln;
}
# ---------------------------------------------------------------------------
# Сохранить Объект:
# store_object( 'tablename', key => 'value', key => 'value' )
# object => {
# key => 'value',
# }
# ----------------------------------------------------------------------------
sub store_object {
my $self = shift;
my $tablename = shift;
return unless $tablename;
my %object = @_;
my $request;
my @values;
my $id = 0;
if ( exists $object{id} && $object{id} ) {
$id = $object{id};
$request = "UPDATE $tablename SET " ;
my $i = 0;
foreach my $field ( keys %object ) {
next if $field eq 'id';
$request .= ',' if $i++;
$request .= " $field = ?";
push @values, $object{$field};
}
$request .= ' WHERE id='.$object{id};
} else {
$id = $self->get_next_id($tablename);
$request = "INSERT INTO $tablename " ;
my @keys = grep { $_ ne 'id' } keys %object;
@values = map { $object{$_} } @keys;
unshift @keys, 'id';
unshift @values, $id;
$request .= " (".join(', ', @keys).") ";
$request .= " VALUES (".join(', ', map { '?' } @keys).")";
}
warn $request."\n" if $DEBUG;
warn "Values: [".join(',',@values)."]\n" if $DEBUG;
my $dbh = $self->SQL;
my $result = $dbh->prepare($request);
my $res = $result->execute(@values);
unless ( $res ) {
warn "OBJECT STORE ERROR: [".$result->errstr."]\n";
}
$result->finish;
return $res ? $id : undef;
}
# ---------------------------------------------------------------------------
# Сохранить Объект с автоинкрементом:
#
# store_object_autoinc( 'tablename', key => 'value', key => 'value' )
# object => {
# key => 'value',
# }
#
# ----------------------------------------------------------------------------
sub store_object_autoinc {
my $self = shift;
my $tablename = shift;
return unless $tablename;
my (%object) = @_;
my $request;
my @values;
my $id = 0;
if ( exists $object{id} && $object{id} ) {
$id = $object{id};
$request = "UPDATE $tablename SET " ;
my $i = 0;
foreach my $field ( keys %object ) {
next if $field eq 'id';
$request .= ',' if $i++;
$request .= " $field = ?";
push @values, $object{$field};
}
$request .= ' WHERE id='.$object{id};
} else {
$request = "INSERT INTO $tablename " ;
my @keys = grep { $_ ne 'id' } keys %object;
@values = map { $object{$_} } @keys;
$request .= " (".join(', ', @keys).") ";
$request .= " VALUES (".join(', ', map { '?' } @keys).")";
}
warn $request."\n" if $DEBUG;
warn "Values: [".join(',', map { !defined $_ ? 'NULL' : $_ } @values)."]\n" if $DEBUG;
my $dbh = $self->SQL;
my $result = $dbh->prepare($request);
my $res = $result->execute(@values);
unless ( $res ) {
warn "OBJECT STORE ERROR: [".$result->errstr."]\n";
}
unless ( $id ) {
$id = $dbh->last_insert_id(undef, undef, undef, undef);
warn "INSERT TRACK. ID = [$id]\n";
}
$result->finish;
return $res ? $id : undef;
}
# ---------------------------------------------------------------------------
# Удалить Объект:
#
# ----------------------------------------------------------------------------
sub delete_object {
my $self = shift;
my $tablename = shift;
return unless $tablename;
my %opts = @_;
my $request;
if ( exists $opts{id} && $opts{id} ) {
$request = "DELETE FROM $tablename WHERE id = ?";
}
warn $request if $DEBUG;
my $dbh = $self->SQL;
my $result = $dbh->prepare($request);
$result->execute($opts{id});
$result->finish;
}
1;