| 1 | package AmberDB::Base::Index; | ||
| 2 | |||
| 3 | use 5.016; | ||
| 4 | use warnings; | ||
| 5 | use Carp qw(croak cluck); | ||
| 6 | |||
| 7 | our $VERSION = '5.26.6'; | ||
| 8 | my $CREATED = '2021-05-24'; | ||
| 9 | |||
| 10 | # ===================================================================== | ||
| 11 | # OPERATOR AND FIELD RESOLUTION HELPERS (Shared across Index modules) | ||
| 12 | # ===================================================================== | ||
| 13 | |||
| 14 | # $adb->_cmp_op($a, $op, $b); | ||
| 15 | # ------------------------------------------------ | ||
| 16 | sub _cmp_op { | ||
| 17 | |||
| 18 | my ( $self, $a, $op, $b ) = @_; | ||
| 19 | |||
| 20 | return 0 unless defined $a && $a ne '' && defined $b && $b ne ''; | ||
| 21 | my $num = ( $a =~ /^-?[0-9.]+$/ && $b =~ /^-?[0-9.]+$/ ); | ||
| 22 | if ( $op eq 'eq' || $op eq '==' ) { return $num ? $a == $b : $a eq $b } | ||
| 23 | elsif ( $op eq 'ne' || $op eq '!=' ) { return $num ? $a != $b : $a ne $b } | ||
| 24 | elsif ( $op eq '>' ) { return $a > $b } | ||
| 25 | elsif ( $op eq '>=' ) { return $a >= $b } | ||
| 26 | elsif ( $op eq '<' ) { return $a < $b } | ||
| 27 | elsif ( $op eq '<=' ) { return $a <= $b } | ||
| 28 | return 0; | ||
| 29 | } | ||
| 30 | |||
| 31 | # $adb->_resolve_field_value($table_info, \@record, $field_spec); | ||
| 32 | # ------------------------------------------------ | ||
| 33 | sub _resolve_field_value { | ||
| 34 | |||
| 35 | my ( $self, $table_info, $record, $field_spec, $rdbm_recs ) = @_; | ||
| 36 | |||
| 37 | return '' unless defined $field_spec && defined $record && ref($record) eq 'ARRAY'; | ||
| 38 | |||
| 39 | # 1. Relational RDBM or Nested Array: "2->14" | ||
| 40 | if ( $field_spec =~ /^(\d+)->(\d+)$/ ) { | ||
| 41 | my ( $b1, $b2 ) = ( $1, $2 ); | ||
| 42 | my $blk_info = $table_info->{blocks}->[$b1] if ref($table_info) eq 'HASH' && $table_info->{blocks}; | ||
| 43 | |||
| 44 | # RDBM relational resolution | ||
| 45 | if ( $blk_info && $blk_info->{rdbm} ) { | ||
| 46 | my $ref_table; | ||
| 47 | if ( ref( $blk_info->{rdbm} ) eq 'HASH' ) { | ||
| 48 | $ref_table = $blk_info->{rdbm}->{table}; | ||
| 49 | } | ||
| 50 | elsif ( $blk_info->{rdbm} =~ /^([\w\-]+)[;:,]/ ) { | ||
| 51 | $ref_table = $1; | ||
| 52 | } | ||
| 53 | |||
| 54 | if ($ref_table) { | ||
| 55 | my $ref_info = $self->table_info($ref_table); | ||
| 56 | if ( $self->config('use_simple') || ( $ref_info && $ref_info->{use_simple} ) ) { | ||
| 57 | cluck "[AMBERDB_SCHEMA] Cannot resolve RDBM relation to simple table '$ref_table'\n"; | ||
| 58 | return ''; | ||
| 59 | } | ||
| 60 | } | ||
| 61 | |||
| 62 | my $ref_id = $record->[$b1]; | ||
| 63 | if ( $ref_table && defined $ref_id && $ref_id ne '' ) { | ||
| 64 | # 1. AmberDB resmi L1 cache'den dogrudan oku ($self->get_cache) | ||
| 65 | my $cached_rec = $self->get_cache( $ref_table, $ref_id ); | ||
| 66 | if ( defined $cached_rec ) { | ||
| 67 | my @rec = ref($cached_rec) eq 'ARRAY' ? @$cached_rec : ($cached_rec); | ||
| 68 | return $rec[$b2] // ''; | ||
| 69 | } | ||
| 70 | |||
| 71 | # 2. Onceden getirilmis toplu rdbm_recs hashi varsa oku ve cache'e yaz | ||
| 72 | if ( $rdbm_recs && $rdbm_recs->{$ref_table} && exists $rdbm_recs->{$ref_table}->{$ref_id} ) { | ||
| 73 | my $ref_rec = $rdbm_recs->{$ref_table}->{$ref_id}; | ||
| 74 | $self->set_cache( $ref_table, $ref_id, $ref_rec ); | ||
| 75 | return ( ref($ref_rec) eq 'ARRAY' ? $ref_rec->[$b2] : $ref_rec ) // ''; | ||
| 76 | } | ||
| 77 | |||
| 78 | # 3. Geriye donuk tekil okuma: saf table_readid kullan ve cache'e kaydet | ||
| 79 | my $ref_path = $self->table_path($ref_table) . "." . ( $self->{db_ext} || 'db' ); | ||
| 80 | my @ref_rec = $self->table_readid( $ref_path, $ref_id ); | ||
| 81 | if (@ref_rec) { | ||
| 82 | $self->set_cache( $ref_table, $ref_id, \@ref_rec ); | ||
| 83 | return $ref_rec[$b2] // ''; | ||
| 84 | } | ||
| 85 | return ''; | ||
| 86 | } | ||
| 87 | return ''; | ||
| 88 | } | ||
| 89 | # Nested Array Reference | ||
| 90 | elsif ( ref( $record->[$b1] ) eq 'ARRAY' ) { | ||
| 91 | return $record->[$b1]->[$b2] // ''; | ||
| 92 | } | ||
| 93 | # Tab/comma separated string | ||
| 94 | else { | ||
| 95 | my $raw = $record->[$b1] // ''; | ||
| 96 | my @parts = split /[\t,]/, $raw; | ||
| 97 | return $parts[$b2] // ''; | ||
| 98 | } | ||
| 99 | } | ||
| 100 | |||
| 101 | # 2. Direct Field: 5 | ||
| 102 | return $record->[$field_spec] // ''; | ||
| 103 | } | ||
| 104 | |||
| 105 | # my @vals = $adb->field_to_list($value, [$table_path], [$table_info], [$blk]); | ||
| 106 | # Converts ARRAY ref, comma/semicolon delimited string or single value to a normalized list. | ||
| 107 | # When $table_path and $blk are provided, resolves text strings to numeric IDs from .unq (read-only). | ||
| 108 | # ------------------------------------------------ | ||
| 109 | sub field_to_list { | ||
| 110 | |||
| 111 | my $self = shift; | ||
| 112 | my $value = shift; | ||
| 113 | |||
| 114 | return () unless defined $value && $value ne ''; | ||
| 115 | |||
| 116 | # Optional mode argument ('read' or 'write') for backward compatibility | ||
| 117 | if ( defined $_[0] && ( $_[0] eq 'read' || $_[0] eq 'write' ) ) { | ||
| 118 | shift; | ||
| 119 | } | ||
| 120 | |||
| 121 | my @list; | ||
| 122 | |||
| 123 | if ( !ref($value) ) { | ||
| 124 | if ( index($value, ',') == -1 && index($value, ';') == -1 ) { | ||
| 125 | my $trimmed = $self->trim_space( "$value", 1 ); | ||
| 126 | push @list, $trimmed if defined $trimmed && $trimmed ne ''; | ||
| 127 | } | ||
| 128 | else { | ||
| 129 | for my $part ( split /[,;]/, $value ) { | ||
| 130 | my $trimmed = $self->trim_space( $part, 1 ); | ||
| 131 | push @list, $trimmed if defined $trimmed && $trimmed ne ''; | ||
| 132 | } | ||
| 133 | } | ||
| 134 | } | ||
| 135 | elsif ( ref($value) eq 'ARRAY' ) { | ||
| 136 | my @stack = @$value; | ||
| 137 | while (@stack) { | ||
| 138 | my $item = shift @stack; | ||
| 139 | if ( ref($item) eq 'ARRAY' ) { | ||
| 140 | unshift @stack, @$item; | ||
| 141 | } | ||
| 142 | elsif ( defined $item && $item ne '' ) { | ||
| 143 | my $trimmed = $self->trim_space( "$item", 1 ); | ||
| 144 | push @list, $trimmed if defined $trimmed && $trimmed ne ''; | ||
| 145 | } | ||
| 146 | } | ||
| 147 | } | ||
| 148 | |||
| 149 | return @list; | ||
| 150 | } | ||
| 151 | |||
| 152 | sub get_fieldlist { | ||
| 153 | my $self = shift; | ||
| 154 | return $self->field_to_list(@_); | ||
| 155 | } | ||
| 156 | |||
| 157 | sub set_fieldlist { | ||
| 158 | my $self = shift; | ||
| 159 | return $self->field_to_list(@_); | ||
| 160 | } | ||
| 161 | |||
| 162 | # my ( $target_table, $target_blk ) = $adb->rdbm_target($table_info, $blk); | ||
| 163 | # ------------------------------------------------ | ||
| 164 | sub rdbm_target { | ||
| 165 | my ( $self, $table_info, $blk ) = @_; | ||
| 166 | return if $self->config('use_simple'); | ||
| 167 | return unless ref($table_info) eq 'HASH' && $table_info->{blocks}; | ||
| 168 | return if $table_info->{use_simple}; | ||
| 169 | return unless $blk; | ||
| 170 | |||
| 171 | my $b_def; | ||
| 172 | if ( ref( $table_info->{blocks} ) eq 'ARRAY' ) { | ||
| 173 | return unless exists $table_info->{blocks}->[$blk]; | ||
| 174 | $b_def = $table_info->{blocks}->[$blk]; | ||
| 175 | } | ||
| 176 | elsif ( ref( $table_info->{blocks} ) eq 'HASH' ) { | ||
| 177 | return unless exists $table_info->{blocks}->{$blk}; | ||
| 178 | $b_def = $table_info->{blocks}->{$blk}; | ||
| 179 | } | ||
| 180 | else { | ||
| 181 | return; | ||
| 182 | } | ||
| 183 | return unless ref($b_def) eq 'HASH' && $b_def->{rdbm}; | ||
| 184 | my ( $t, $b ); | ||
| 185 | if ( ref( $b_def->{rdbm} ) eq 'HASH' ) { | ||
| 186 | $t = $b_def->{rdbm}->{table}; | ||
| 187 | $b = $b_def->{rdbm}->{display} // 1; | ||
| 188 | } | ||
| 189 | elsif ( $b_def->{rdbm} =~ /^([\w\-]+)[;:,|](\d+)/ ) { | ||
| 190 | ( $t, $b ) = ( $1, $2 ); | ||
| 191 | $b_def->{rdbm} = { table => $t, display => $b }; | ||
| 192 | } | ||
| 193 | return unless defined $t; | ||
| 194 | |||
| 195 | my $target_info = $self->table_info($t); | ||
| 196 | return if $target_info && ( $target_info->{use_simple} || ( $target_info->{id_type} && $target_info->{id_type} eq 'ascii' ) ); | ||
| 197 | |||
| 198 | return ( $t, $b ); | ||
| 199 | } | ||
| 200 | |||
| 201 | # my @record = $self->repeat_fields($table_info, @record); | ||
| 202 | # ------------------------------------------------ | ||
| 203 | sub repeat_fields { | ||
| 204 | |||
| 205 | my ( $self, $table_info, @record ) = @_; | ||
| 206 | |||
| 207 | ref($table_info) eq 'HASH' or return @record; | ||
| 208 | |||
| 209 | my $rep_ids = $table_info->{repeat_ids}; | ||
| 210 | my $rep_start = $table_info->{repeat_start}; | ||
| 211 | |||
| 212 | return @record unless $rep_ids && $rep_start; | ||
| 213 | |||
| 214 | if ( $rep_start <= $#record ) { | ||
| 215 | my @repeat = @record[ $rep_start .. $#record ]; | ||
| 216 | $record[$rep_ids] = join ",", grep { defined $_ && length($_) } map { ref($_) eq 'ARRAY' ? $_->[0] : $_ } @repeat; | ||
| 217 | } | ||
| 218 | else { | ||
| 219 | $record[$rep_ids] = "" if $rep_ids < @record; | ||
| 220 | } | ||
| 221 | |||
| 222 | return @record; | ||
| 223 | } | ||
| 224 | |||
| 225 | # ( $ok, $err ) = $adb->unique_check( $table_path, $table_info, $rid, \@fields, $has_id ); | ||
| 226 | # Validates that any block with valid => "unique" is not already occupied by another record ID. | ||
| 227 | # ------------------------------------------------ | ||
| 228 | sub unique_check { | ||
| 229 | my ( $self, $table_path, $table_info, $rid, $fields, $has_id ) = @_; | ||
| 230 | return 1 unless ref($table_info) eq 'HASH' && ref($table_info->{blocks}) eq 'ARRAY'; | ||
| 231 | return 1 unless ref($fields) eq 'ARRAY' && @$fields; | ||
| 232 | |||
| 233 | my @blocks = @{ $table_info->{blocks} }; | ||
| 234 | for ( my $i = 0 ; $i < @$fields ; $i++ ) { | ||
| 235 | my $blk_idx = $has_id ? $i : ( $i + 1 ); | ||
| 236 | last if $blk_idx >= @blocks; | ||
| 237 | |||
| 238 | my $b = $blocks[$blk_idx]; | ||
| 239 | next unless ref($b) eq 'HASH' && defined $b->{valid} && $b->{valid} =~ /unique/i; | ||
| 240 | |||
| 241 | my $val = $fields->[$i]; | ||
| 242 | next unless defined $val && $val ne ''; | ||
| 243 | |||
| 244 | my $unq_path = "${table_path}.unq"; | ||
| 245 | next unless -e $unq_path || $self->{_db}->{$unq_path}; | ||
| 246 | |||
| 247 | my ($existing_rid) = $self->index_get( $unq_path, "$blk_idx:s:$val", 'raw' ); | ||
| 248 | |||
| 249 | if ( defined $existing_rid && $existing_rid ne '' && ( !defined $rid || $existing_rid ne $rid ) ) { | ||
| 250 | my $b_name = $b->{name} || $b->{id} || "Block $blk_idx"; | ||
| 251 | return ( 0, "Duplicate unique key '$val' on '$b_name' ($b->{id}) - already registered by record ID: $existing_rid" ); | ||
| 252 | } | ||
| 253 | } | ||
| 254 | return 1; | ||
| 255 | } | ||
| 256 | |||
| 257 | # $adb->unique_add( $table_path, $table_info, \@records ); | ||
| 258 | # Registers unique fields into ${table_path}.unq. | ||
| 259 | # ------------------------------------------------ | ||
| 260 | sub unique_add { | ||
| 261 | my ( $self, $table_path, $table_info, $records ) = @_; | ||
| 262 | return unless ref($table_info) eq 'HASH' && ref($table_info->{blocks}) eq 'ARRAY'; | ||
| 263 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 264 | |||
| 265 | my @blocks = @{ $table_info->{blocks} }; | ||
| 266 | my @unq_blks = grep { ref($blocks[$_]) eq 'HASH' && defined $blocks[$_]->{valid} && $blocks[$_]->{valid} =~ /unique/i } ( 1 .. $#blocks ); | ||
| 267 | return unless @unq_blks; | ||
| 268 | |||
| 269 | my $target_table = ( ref($table_info) eq 'HASH' && $table_info->{name} ) ? $table_info->{name} : undef; | ||
| 270 | if ( !$target_table ) { | ||
| 271 | if ( $table_path =~ m{([^/\\:]+)$} ) { | ||
| 272 | $target_table = $1; | ||
| 273 | } | ||
| 274 | else { | ||
| 275 | $target_table = $table_path; | ||
| 276 | } | ||
| 277 | } | ||
| 278 | |||
| 279 | my %batch_put; | ||
| 280 | for my $blk (@unq_blks) { | ||
| 281 | foreach my $rec (@$records) { | ||
| 282 | my $rid = $rec->[0]; | ||
| 283 | my $val = $rec->[$blk]; | ||
| 284 | next unless defined $val && $val ne ''; | ||
| 285 | |||
| 286 | $batch_put{"$blk:s:$val"} = $rid; | ||
| 287 | $batch_put{"$blk:n:$rid"} = $val; | ||
| 288 | $batch_put{"$blk:lastid"} = $rid; | ||
| 289 | $self->set_cache( $target_table, "$blk:$val", $rid ); | ||
| 290 | $self->set_cache( $target_table, "$blk:lastid", $rid ); | ||
| 291 | } | ||
| 292 | } | ||
| 293 | return unless %batch_put; | ||
| 294 | |||
| 295 | my $unq_path = "${table_path}.unq"; | ||
| 296 | my $unq_opened = 0; | ||
| 297 | if ( !$self->{_db}->{$unq_path} ) { | ||
| 298 | $self->table_write($unq_path); | ||
| 299 | $unq_opened = 1; | ||
| 300 | } | ||
| 301 | |||
| 302 | $self->index_put( $unq_path, \%batch_put, 'raw' ); | ||
| 303 | |||
| 304 | if ($unq_opened) { | ||
| 305 | $self->table_close($unq_path); | ||
| 306 | } | ||
| 307 | } | ||
| 308 | |||
| 309 | # $adb->unique_del( $table_path, $table_info, \@records ); | ||
| 310 | # Removes entries from ${table_path}.unq upon record deletion. | ||
| 311 | # ------------------------------------------------ | ||
| 312 | sub unique_del { | ||
| 313 | my ( $self, $table_path, $table_info, $records ) = @_; | ||
| 314 | return unless ref($table_info) eq 'HASH' && ref($table_info->{blocks}) eq 'ARRAY'; | ||
| 315 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 316 | |||
| 317 | my @blocks = @{ $table_info->{blocks} }; | ||
| 318 | my @unq_blks = grep { ref($blocks[$_]) eq 'HASH' && defined $blocks[$_]->{valid} && $blocks[$_]->{valid} =~ /unique/i } ( 1 .. $#blocks ); | ||
| 319 | return unless @unq_blks; | ||
| 320 | |||
| 321 | my $unq_path = "${table_path}.unq"; | ||
| 322 | return unless -e $unq_path || $self->{_db}->{$unq_path}; | ||
| 323 | |||
| 324 | my @batch_del; | ||
| 325 | for my $blk (@unq_blks) { | ||
| 326 | foreach my $rec (@$records) { | ||
| 327 | my $rid = $rec->[0]; | ||
| 328 | my $val = $rec->[$blk]; | ||
| 329 | next unless defined $val && $val ne ''; | ||
| 330 | |||
| 331 | push @batch_del, "$blk:s:$val", "$blk:n:$rid"; | ||
| 332 | } | ||
| 333 | } | ||
| 334 | return unless @batch_del; | ||
| 335 | |||
| 336 | my $unq_opened = 0; | ||
| 337 | if ( !$self->{_db}->{$unq_path} ) { | ||
| 338 | $self->table_write($unq_path); | ||
| 339 | $unq_opened = 1; | ||
| 340 | } | ||
| 341 | |||
| 342 | $self->index_del( $unq_path, \@batch_del ); | ||
| 343 | |||
| 344 | if ($unq_opened) { | ||
| 345 | $self->table_close($unq_path); | ||
| 346 | } | ||
| 347 | } | ||
| 348 | |||
| 349 | # $adb->unique_modify( $table_path, $table_info, \@pairs ); | ||
| 350 | # Updates ${table_path}.unq when unique field values change. | ||
| 351 | # ------------------------------------------------ | ||
| 352 | sub unique_modify { | ||
| 353 | my ( $self, $table_path, $table_info, $pairs ) = @_; | ||
| 354 | return unless ref($table_info) eq 'HASH' && ref($table_info->{blocks}) eq 'ARRAY'; | ||
| 355 | return unless ref($pairs) eq 'ARRAY' && @$pairs; | ||
| 356 | |||
| 357 | my @blocks = @{ $table_info->{blocks} }; | ||
| 358 | my @unq_blks = grep { ref($blocks[$_]) eq 'HASH' && defined $blocks[$_]->{valid} && $blocks[$_]->{valid} =~ /unique/i } ( 1 .. $#blocks ); | ||
| 359 | return unless @unq_blks; | ||
| 360 | |||
| 361 | my ( %batch_put, @batch_del ); | ||
| 362 | for my $blk (@unq_blks) { | ||
| 363 | foreach my $pair (@$pairs) { | ||
| 364 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 365 | my $ov = $old_rec->[$blk] // ''; | ||
| 366 | my $nv = $new_rec->[$blk] // ''; | ||
| 367 | next if $ov eq $nv; | ||
| 368 | |||
| 369 | if ( $ov ne '' ) { | ||
| 370 | push @batch_del, "$blk:s:$ov"; | ||
| 371 | } | ||
| 372 | if ( $nv ne '' ) { | ||
| 373 | $batch_put{"$blk:s:$nv"} = $rid; | ||
| 374 | $batch_put{"$blk:n:$rid"} = $nv; | ||
| 375 | $batch_put{"$blk:lastid"} = $rid; | ||
| 376 | } | ||
| 377 | } | ||
| 378 | } | ||
| 379 | return unless %batch_put || @batch_del; | ||
| 380 | |||
| 381 | my $unq_path = "${table_path}.unq"; | ||
| 382 | my $unq_opened = 0; | ||
| 383 | if ( !$self->{_db}->{$unq_path} ) { | ||
| 384 | $self->table_write($unq_path); | ||
| 385 | $unq_opened = 1; | ||
| 386 | } | ||
| 387 | |||
| 388 | $self->index_del( $unq_path, \@batch_del ) if @batch_del; | ||
| 389 | $self->index_put( $unq_path, \%batch_put, 'raw' ) if %batch_put; | ||
| 390 | |||
| 391 | if ($unq_opened) { | ||
| 392 | $self->table_close($unq_path); | ||
| 393 | } | ||
| 394 | } | ||
| 395 | |||
| 396 | # $adb->match_add($table_path, $table_info, \@records); | ||
| 397 | # $adb->match_del($table_path, $table_info, \@records); | ||
| 398 | # $adb->match_modify($table_path, $table_info, \@pairs); | ||
| 399 | # records = [ [$rid, @data...], ... ] | ||
| 400 | # pairs = [ [$rid, \@old_rec, \@new_rec], ... ] | ||
| 401 | # ------------------------------------------------ | ||
| 402 | sub match_add { | ||
| 403 | |||
| 404 | my ( $self, $table_path, $table_info, $records, $tier ) = @_; | ||
| 405 | |||
| 406 | return unless exists $table_info->{match_block}; | ||
| 407 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 408 | |||
| 409 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 410 | |||
| 411 | my %acc; | ||
| 412 | foreach my $blk ( @{ $table_info->{match_block} } ) { | ||
| 413 | foreach my $rec (@$records) { | ||
| 414 | my $rid = $rec->[0]; | ||
| 415 | next unless defined $rec->[$blk] && $rec->[$blk] ne ''; | ||
| 416 | my @ids = $self->field_to_list( $rec->[$blk], $table_path, $table_info, $blk ); | ||
| 417 | push @{ $acc{"$pfx$blk:$_"} }, $rid for @ids; | ||
| 418 | } | ||
| 419 | } | ||
| 420 | |||
| 421 | return unless %acc; | ||
| 422 | my $field_path = "${table_path}.fld"; | ||
| 423 | $self->table_write($field_path) or do { | ||
| 424 | $self->transact_error( $field_path, "can't open" ); | ||
| 425 | return; | ||
| 426 | }; | ||
| 427 | my @all_vals = keys %acc; | ||
| 428 | my $existing_map = $self->index_get( $field_path, \@all_vals, 'raw' ); | ||
| 429 | |||
| 430 | my %batch_put; | ||
| 431 | foreach my $k (@all_vals) { | ||
| 432 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 433 | $batch_put{$k} = $self->bin_add( $raw_buf, $acc{$k} ); | ||
| 434 | } | ||
| 435 | $self->index_put( $field_path, \%batch_put, "bin" ); | ||
| 436 | $self->table_close($field_path); | ||
| 437 | } | ||
| 438 | |||
| 439 | sub match_del { | ||
| 440 | |||
| 441 | my ( $self, $table_path, $table_info, $records, $tier ) = @_; | ||
| 442 | |||
| 443 | return unless exists $table_info->{match_block}; | ||
| 444 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 445 | |||
| 446 | my @tiers = ref($tier) eq 'ARRAY' ? @$tier : ( defined $tier && length($tier) ? ($tier) : (undef) ); | ||
| 447 | |||
| 448 | my %acc; | ||
| 449 | foreach my $blk ( @{ $table_info->{match_block} } ) { | ||
| 450 | foreach my $rec (@$records) { | ||
| 451 | my $rid = $rec->[0]; | ||
| 452 | next unless defined $rec->[$blk] && $rec->[$blk] ne ''; | ||
| 453 | my @ids = $self->field_to_list( $rec->[$blk], $table_path, $table_info, $blk ); | ||
| 454 | for my $t (@tiers) { | ||
| 455 | my $pfx = defined $t && $t =~ /^[AB]$/i ? uc("$t") . ":" : ""; | ||
| 456 | push @{ $acc{"$pfx$blk:$_"} }, $rid for @ids; | ||
| 457 | } | ||
| 458 | } | ||
| 459 | } | ||
| 460 | |||
| 461 | return unless %acc; | ||
| 462 | my $field_path = "${table_path}.fld"; | ||
| 463 | return unless -e $field_path; | ||
| 464 | $self->table_write($field_path) or do { | ||
| 465 | $self->transact_error( $field_path, "can't open" ); | ||
| 466 | return; | ||
| 467 | }; | ||
| 468 | my @all_vals = keys %acc; | ||
| 469 | my $existing_map = $self->index_get( $field_path, \@all_vals, 'raw' ); | ||
| 470 | my ( %batch_put, @batch_del ); | ||
| 471 | foreach my $k (@all_vals) { | ||
| 472 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 473 | my $updated = $self->bin_punch( $raw_buf, $acc{$k} ); | ||
| 474 | if ( length($updated) >= 8 ) { | ||
| 475 | $batch_put{$k} = $updated; | ||
| 476 | } | ||
| 477 | else { | ||
| 478 | push @batch_del, $k; | ||
| 479 | } | ||
| 480 | } | ||
| 481 | $self->index_put( $field_path, \%batch_put, "bin" ) if %batch_put; | ||
| 482 | $self->index_del( $field_path, \@batch_del ) if @batch_del; | ||
| 483 | $self->table_close($field_path); | ||
| 484 | } | ||
| 485 | |||
| 486 | sub match_modify { | ||
| 487 | |||
| 488 | my ( $self, $table_path, $table_info, $pairs, $tier ) = @_; | ||
| 489 | |||
| 490 | return unless exists $table_info->{match_block}; | ||
| 491 | return unless ref($pairs) eq 'ARRAY' && @$pairs; | ||
| 492 | |||
| 493 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 494 | |||
| 495 | my ( %del_acc, %add_acc ); | ||
| 496 | foreach my $blk ( @{ $table_info->{match_block} } ) { | ||
| 497 | foreach my $pair (@$pairs) { | ||
| 498 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 499 | my $ov = $old_rec->[$blk] // ''; | ||
| 500 | my $nv = $new_rec->[$blk] // ''; | ||
| 501 | next if $ov eq $nv; | ||
| 502 | |||
| 503 | my %old_vals = map { $_ => 1 } $self->field_to_list( $ov, $table_path, $table_info, $blk ); | ||
| 504 | my %new_vals = map { $_ => 1 } $self->field_to_list( $nv, $table_path, $table_info, $blk ); | ||
| 505 | |||
| 506 | # Only remove from values that were removed | ||
| 507 | foreach my $v ( keys %old_vals ) { | ||
| 508 | push @{ $del_acc{"$pfx$blk:$v"} }, $rid unless $new_vals{$v}; | ||
| 509 | } | ||
| 510 | # Only add to values that are newly added | ||
| 511 | foreach my $v ( keys %new_vals ) { | ||
| 512 | push @{ $add_acc{"$pfx$blk:$v"} }, $rid unless $old_vals{$v}; | ||
| 513 | } | ||
| 514 | } | ||
| 515 | } | ||
| 516 | |||
| 517 | return unless %del_acc || %add_acc; | ||
| 518 | my $field_path = "${table_path}.fld"; | ||
| 519 | $self->table_write($field_path) or do { | ||
| 520 | $self->transact_error( $field_path, "can't open" ); | ||
| 521 | return; | ||
| 522 | }; | ||
| 523 | my %all_vals = map { $_ => 1 } ( keys %del_acc, keys %add_acc ); | ||
| 524 | my @key_list = keys %all_vals; | ||
| 525 | my $existing_map = $self->index_get( $field_path, \@key_list, 'raw' ); | ||
| 526 | my ( %batch_put, @batch_del ); | ||
| 527 | |||
| 528 | foreach my $k (@key_list) { | ||
| 529 | $k or next; | ||
| 530 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 531 | if ( $del_acc{$k} ) { | ||
| 532 | $raw_buf = $self->bin_punch( $raw_buf, $del_acc{$k} ); | ||
| 533 | } | ||
| 534 | if ( $add_acc{$k} ) { | ||
| 535 | $raw_buf = $self->bin_add( $raw_buf, $add_acc{$k} ); | ||
| 536 | } | ||
| 537 | if ( length($raw_buf) >= 8 ) { | ||
| 538 | $batch_put{$k} = $raw_buf; | ||
| 539 | } | ||
| 540 | else { | ||
| 541 | push @batch_del, $k; | ||
| 542 | } | ||
| 543 | } | ||
| 544 | $self->index_put( $field_path, \%batch_put, "bin" ) if %batch_put; | ||
| 545 | $self->index_del( $field_path, \@batch_del ) if @batch_del; | ||
| 546 | $self->table_close($field_path); | ||
| 547 | } | ||
| 548 | |||
| 549 | sub search_add { | ||
| 550 | |||
| 551 | my ( $self, $table_path, $table_info, $tableid, $records, $tier ) = @_; | ||
| 552 | |||
| 553 | return unless exists $table_info->{search_block}; | ||
| 554 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 555 | |||
| 556 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 557 | |||
| 558 | # 1. Identify RDBM blocks and prepare pre-fetch | ||
| 559 | my %rdbm_blocks; | ||
| 560 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 561 | my ( $real_blk, $src_table, $src_display ) = | ||
| 562 | ref($blk) eq 'ARRAY' ? ( $blk->[0], $blk->[1], $blk->[2] ) | ||
| 563 | : ( $blk, undef, undef ); | ||
| 564 | |||
| 565 | if ( !$src_table ) { | ||
| 566 | ( $src_table, $src_display ) = $self->rdbm_target( $table_info, $real_blk ); | ||
| 567 | } | ||
| 568 | if ( $src_table ) { | ||
| 569 | $src_display //= 1; | ||
| 570 | $rdbm_blocks{$real_blk} = { table => $src_table, display => $src_display }; | ||
| 571 | } | ||
| 572 | } | ||
| 573 | |||
| 574 | # 2. Collect unique foreign IDs across all records | ||
| 575 | my ( %foreign_ids, %rdbm_recs ); | ||
| 576 | if ( %rdbm_blocks ) { | ||
| 577 | for my $rec (@$records) { | ||
| 578 | for my $real_blk ( keys %rdbm_blocks ) { | ||
| 579 | my $val = $rec->[$real_blk]; | ||
| 580 | next unless defined $val && $val ne ''; | ||
| 581 | my $target_table = $rdbm_blocks{$real_blk}->{table}; | ||
| 582 | for my $id ( split /[,;]/, $val ) { | ||
| 583 | $id =~ s/^\s+|\s+$//g; | ||
| 584 | $foreign_ids{$target_table}->{$id} = 1 if $id =~ /^\d+$/; | ||
| 585 | } | ||
| 586 | } | ||
| 587 | } | ||
| 588 | for my $target_table ( keys %foreign_ids ) { | ||
| 589 | my @ids = keys %{ $foreign_ids{$target_table} }; | ||
| 590 | next unless @ids; | ||
| 591 | my @target_records = $self->read_list( $target_table, \@ids ); | ||
| 592 | $rdbm_recs{$target_table} = { map { $_->[0] => $_ } @target_records }; | ||
| 593 | } | ||
| 594 | } | ||
| 595 | |||
| 596 | # 3. Tokenize words with in-memory lookup | ||
| 597 | my %word_acc; | ||
| 598 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 599 | my $real_blk = ref($blk) eq 'ARRAY' ? $blk->[0] : $blk; | ||
| 600 | my $rdbm_info = $rdbm_blocks{$real_blk}; | ||
| 601 | |||
| 602 | foreach my $rec (@$records) { | ||
| 603 | my $rid = $rec->[0]; | ||
| 604 | my $val = $rec->[$real_blk]; | ||
| 605 | if ( $rdbm_info && defined $val && $val ne '' ) { | ||
| 606 | my $target_table = $rdbm_info->{table}; | ||
| 607 | my $disp = $rdbm_info->{display}; | ||
| 608 | my @parts; | ||
| 609 | for my $sid ( split /[,;]/, $val ) { | ||
| 610 | $sid =~ s/^\s+|\s+$//g; | ||
| 611 | if ( my $target_rec = $rdbm_recs{$target_table}->{$sid} ) { | ||
| 612 | my $name = $target_rec->[$disp]; | ||
| 613 | push @parts, $name if defined $name && length($name); | ||
| 614 | } | ||
| 615 | } | ||
| 616 | $val = join( ' ', @parts ); | ||
| 617 | } | ||
| 618 | next unless defined $val && $val ne ''; | ||
| 619 | my %words = $self->get_words( $val, "write", $tableid ); | ||
| 620 | push @{ $word_acc{"$pfx$real_blk:$_"} }, $rid for keys %words; | ||
| 621 | } | ||
| 622 | } | ||
| 623 | |||
| 624 | return unless %word_acc; | ||
| 625 | my $search_path = "${table_path}.src"; | ||
| 626 | $self->table_write($search_path) or do { | ||
| 627 | $self->transact_error( $search_path, "can't open" ); | ||
| 628 | return; | ||
| 629 | }; | ||
| 630 | my @all_words = grep { length } keys %word_acc; | ||
| 631 | my $existing_map = $self->index_get( $search_path, \@all_words, 'raw' ); | ||
| 632 | |||
| 633 | my %batch_put; | ||
| 634 | foreach my $k (@all_words) { | ||
| 635 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 636 | $batch_put{$k} = $self->bin_add( $raw_buf, $word_acc{$k} ); | ||
| 637 | } | ||
| 638 | $self->index_put( $search_path, \%batch_put, "bin" ); | ||
| 639 | $self->table_close($search_path); | ||
| 640 | } | ||
| 641 | |||
| 642 | sub search_del { | ||
| 643 | |||
| 644 | my ( $self, $table_path, $table_info, $tableid, $records, $tier ) = @_; | ||
| 645 | |||
| 646 | return unless exists $table_info->{search_block}; | ||
| 647 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 648 | |||
| 649 | my @tiers = ref($tier) eq 'ARRAY' ? @$tier : ( defined $tier && length($tier) ? ($tier) : (undef) ); | ||
| 650 | |||
| 651 | # 1. Identify RDBM blocks and prepare pre-fetch | ||
| 652 | my %rdbm_blocks; | ||
| 653 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 654 | my ( $real_blk, $src_table, $src_display ) = | ||
| 655 | ref($blk) eq 'ARRAY' ? ( $blk->[0], $blk->[1], $blk->[2] ) | ||
| 656 | : ( $blk, undef, undef ); | ||
| 657 | |||
| 658 | if ( !$src_table ) { | ||
| 659 | ( $src_table, $src_display ) = $self->rdbm_target( $table_info, $real_blk ); | ||
| 660 | } | ||
| 661 | if ( $src_table ) { | ||
| 662 | $src_display //= 1; | ||
| 663 | $rdbm_blocks{$real_blk} = { table => $src_table, display => $src_display }; | ||
| 664 | } | ||
| 665 | } | ||
| 666 | |||
| 667 | # 2. Collect unique foreign IDs across all records | ||
| 668 | my ( %foreign_ids, %rdbm_recs ); | ||
| 669 | if ( %rdbm_blocks ) { | ||
| 670 | for my $rec (@$records) { | ||
| 671 | for my $real_blk ( keys %rdbm_blocks ) { | ||
| 672 | my $val = $rec->[$real_blk]; | ||
| 673 | next unless defined $val && $val ne ''; | ||
| 674 | my $target_table = $rdbm_blocks{$real_blk}->{table}; | ||
| 675 | for my $id ( split /[,;]/, $val ) { | ||
| 676 | $id =~ s/^\s+|\s+$//g; | ||
| 677 | $foreign_ids{$target_table}->{$id} = 1 if $id =~ /^\d+$/; | ||
| 678 | } | ||
| 679 | } | ||
| 680 | } | ||
| 681 | for my $target_table ( keys %foreign_ids ) { | ||
| 682 | my @ids = keys %{ $foreign_ids{$target_table} }; | ||
| 683 | next unless @ids; | ||
| 684 | my @target_records = $self->read_list( $target_table, \@ids ); | ||
| 685 | $rdbm_recs{$target_table} = { map { $_->[0] => $_ } @target_records }; | ||
| 686 | } | ||
| 687 | } | ||
| 688 | |||
| 689 | # 3. Tokenize words with in-memory lookup | ||
| 690 | my %word_acc; | ||
| 691 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 692 | my $real_blk = ref($blk) eq 'ARRAY' ? $blk->[0] : $blk; | ||
| 693 | my $rdbm_info = $rdbm_blocks{$real_blk}; | ||
| 694 | |||
| 695 | foreach my $rec (@$records) { | ||
| 696 | my $rid = $rec->[0]; | ||
| 697 | my $val = $rec->[$real_blk]; | ||
| 698 | if ( $rdbm_info && defined $val && $val ne '' ) { | ||
| 699 | my $target_table = $rdbm_info->{table}; | ||
| 700 | my $disp = $rdbm_info->{display}; | ||
| 701 | my @parts; | ||
| 702 | for my $sid ( split /[,;]/, $val ) { | ||
| 703 | $sid =~ s/^\s+|\s+$//g; | ||
| 704 | if ( my $target_rec = $rdbm_recs{$target_table}->{$sid} ) { | ||
| 705 | my $name = $target_rec->[$disp]; | ||
| 706 | push @parts, $name if defined $name && length($name); | ||
| 707 | } | ||
| 708 | } | ||
| 709 | $val = join( ' ', @parts ); | ||
| 710 | } | ||
| 711 | next unless defined $val && $val ne ''; | ||
| 712 | my %words = $self->get_words( $val, "write", $tableid ); | ||
| 713 | for my $t (@tiers) { | ||
| 714 | my $pfx = defined $t && $t =~ /^[AB]$/i ? uc("$t") . ":" : ""; | ||
| 715 | push @{ $word_acc{"$pfx$real_blk:$_"} }, $rid for keys %words; | ||
| 716 | } | ||
| 717 | } | ||
| 718 | } | ||
| 719 | |||
| 720 | return unless %word_acc; | ||
| 721 | my $search_path = "${table_path}.src"; | ||
| 722 | return unless -e $search_path; | ||
| 723 | |||
| 724 | $self->table_write($search_path) or do { | ||
| 725 | $self->transact_error( $search_path, "can't open" ); | ||
| 726 | return; | ||
| 727 | }; | ||
| 728 | my @all_words = grep { length } keys %word_acc; | ||
| 729 | my $existing_map = $self->index_get( $search_path, \@all_words, 'raw' ); | ||
| 730 | my ( %batch_put, @batch_del ); | ||
| 731 | foreach my $k (@all_words) { | ||
| 732 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 733 | my $updated = $self->bin_punch( $raw_buf, $word_acc{$k} ); | ||
| 734 | if ( length($updated) >= 8 ) { | ||
| 735 | $batch_put{$k} = $updated; | ||
| 736 | } | ||
| 737 | else { | ||
| 738 | push @batch_del, $k; | ||
| 739 | } | ||
| 740 | } | ||
| 741 | $self->index_put( $search_path, \%batch_put, "bin" ) if %batch_put; | ||
| 742 | $self->index_del( $search_path, \@batch_del ) if @batch_del; | ||
| 743 | $self->table_close($search_path); | ||
| 744 | } | ||
| 745 | |||
| 746 | sub search_modify { | ||
| 747 | |||
| 748 | my ( $self, $table_path, $table_info, $tableid, $pairs, $tier ) = @_; | ||
| 749 | |||
| 750 | return unless exists $table_info->{search_block}; | ||
| 751 | return unless ref($pairs) eq 'ARRAY' && @$pairs; | ||
| 752 | |||
| 753 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 754 | |||
| 755 | # 1. Identify RDBM blocks | ||
| 756 | my %rdbm_blocks; | ||
| 757 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 758 | my ( $real_blk, $src_table, $src_display ) = | ||
| 759 | ref($blk) eq 'ARRAY' ? ( $blk->[0], $blk->[1], $blk->[2] ) | ||
| 760 | : ( $blk, undef, undef ); | ||
| 761 | |||
| 762 | if ( !$src_table ) { | ||
| 763 | ( $src_table, $src_display ) = $self->rdbm_target( $table_info, $real_blk ); | ||
| 764 | } | ||
| 765 | if ( $src_table ) { | ||
| 766 | $src_display //= 1; | ||
| 767 | $rdbm_blocks{$real_blk} = { table => $src_table, display => $src_display }; | ||
| 768 | } | ||
| 769 | } | ||
| 770 | |||
| 771 | # 2. Collect unique foreign IDs across old and new records | ||
| 772 | my ( %foreign_ids, %rdbm_recs ); | ||
| 773 | if ( %rdbm_blocks ) { | ||
| 774 | for my $pair (@$pairs) { | ||
| 775 | my ( undef, $old_rec, $new_rec ) = @$pair; | ||
| 776 | for my $rec ( $old_rec, $new_rec ) { | ||
| 777 | next unless ref($rec) eq 'ARRAY'; | ||
| 778 | for my $real_blk ( keys %rdbm_blocks ) { | ||
| 779 | my $val = $rec->[$real_blk]; | ||
| 780 | next unless defined $val && $val ne ''; | ||
| 781 | my $target_table = $rdbm_blocks{$real_blk}->{table}; | ||
| 782 | for my $id ( split /[,;]/, $val ) { | ||
| 783 | $id =~ s/^\s+|\s+$//g; | ||
| 784 | $foreign_ids{$target_table}->{$id} = 1 if $id =~ /^\d+$/; | ||
| 785 | } | ||
| 786 | } | ||
| 787 | } | ||
| 788 | } | ||
| 789 | for my $target_table ( keys %foreign_ids ) { | ||
| 790 | my @ids = keys %{ $foreign_ids{$target_table} }; | ||
| 791 | next unless @ids; | ||
| 792 | my @target_records = $self->read_list( $target_table, \@ids ); | ||
| 793 | $rdbm_recs{$target_table} = { map { $_->[0] => $_ } @target_records }; | ||
| 794 | } | ||
| 795 | } | ||
| 796 | |||
| 797 | my $resolve_val = sub { | ||
| 798 | my ( $rec, $real_blk ) = @_; | ||
| 799 | my $val = $rec->[$real_blk]; | ||
| 800 | if ( my $rdbm_info = $rdbm_blocks{$real_blk} ) { | ||
| 801 | if ( defined $val && $val ne '' ) { | ||
| 802 | my $target_table = $rdbm_info->{table}; | ||
| 803 | my $disp = $rdbm_info->{display}; | ||
| 804 | my @parts; | ||
| 805 | for my $sid ( split /[,;]/, $val ) { | ||
| 806 | $sid =~ s/^\s+|\s+$//g; | ||
| 807 | if ( my $target_rec = $rdbm_recs{$target_table}->{$sid} ) { | ||
| 808 | my $name = $target_rec->[$disp]; | ||
| 809 | push @parts, $name if defined $name && length($name); | ||
| 810 | } | ||
| 811 | } | ||
| 812 | $val = join( ' ', @parts ); | ||
| 813 | } | ||
| 814 | } | ||
| 815 | return $val // ''; | ||
| 816 | }; | ||
| 817 | |||
| 818 | my ( %del_acc, %add_acc ); | ||
| 819 | |||
| 820 | foreach my $blk ( @{ $table_info->{search_block} } ) { | ||
| 821 | my $real_blk = ref($blk) eq 'ARRAY' ? $blk->[0] : $blk; | ||
| 822 | |||
| 823 | foreach my $pair (@$pairs) { | ||
| 824 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 825 | my $old_val = $resolve_val->( $old_rec, $real_blk ); | ||
| 826 | my $new_val = $resolve_val->( $new_rec, $real_blk ); | ||
| 827 | next if $old_val eq $new_val; | ||
| 828 | |||
| 829 | my %old_words = $self->get_words( $old_val, "write", $tableid ); | ||
| 830 | my %new_words = $self->get_words( $new_val, "write", $tableid ); | ||
| 831 | |||
| 832 | my %diff; | ||
| 833 | $diff{$_} = 1 for keys %old_words; | ||
| 834 | for my $w ( keys %new_words ) { $diff{$w} = exists $diff{$w} ? 2 : 3 } | ||
| 835 | for my $w ( keys %diff ) { | ||
| 836 | if ( $diff{$w} == 1 ) { push @{ $del_acc{"$pfx$real_blk:$w"} }, $rid } | ||
| 837 | elsif ( $diff{$w} == 3 ) { push @{ $add_acc{"$pfx$real_blk:$w"} }, $rid } | ||
| 838 | } | ||
| 839 | } | ||
| 840 | } | ||
| 841 | |||
| 842 | return unless %del_acc || %add_acc; | ||
| 843 | my $search_path = "${table_path}.src"; | ||
| 844 | $self->table_write($search_path) or do { | ||
| 845 | $self->transact_error( $search_path, "can't open" ); | ||
| 846 | return; | ||
| 847 | }; | ||
| 848 | |||
| 849 | my %all_words = map { $_ => 1 } ( keys %del_acc, keys %add_acc ); | ||
| 850 | my @key_list = keys %all_words; | ||
| 851 | my $existing_map = $self->index_get( $search_path, \@key_list, 'raw' ); | ||
| 852 | my ( %batch_put, @batch_del ); | ||
| 853 | |||
| 854 | foreach my $k (@key_list) { | ||
| 855 | $k or next; | ||
| 856 | my $raw_buf = $existing_map->{$k} // ''; | ||
| 857 | if ( $del_acc{$k} ) { | ||
| 858 | $raw_buf = $self->bin_punch( $raw_buf, $del_acc{$k} ); | ||
| 859 | } | ||
| 860 | if ( $add_acc{$k} ) { | ||
| 861 | $raw_buf = $self->bin_add( $raw_buf, $add_acc{$k} ); | ||
| 862 | } | ||
| 863 | if ( length($raw_buf) >= 8 ) { | ||
| 864 | $batch_put{$k} = $raw_buf; | ||
| 865 | } | ||
| 866 | else { | ||
| 867 | push @batch_del, $k; | ||
| 868 | } | ||
| 869 | } | ||
| 870 | $self->index_put( [ $search_path, $tableid ], \%batch_put, "bin" ) if %batch_put; | ||
| 871 | $self->index_del( [ $search_path, $tableid ], \@batch_del ) if @batch_del; | ||
| 872 | $self->table_close($search_path); | ||
| 873 | } | ||
| 874 | |||
| 875 | # Appends new rid(s) to .inx file: updates keys, count, lastid. | ||
| 876 | # $new_rids = \@ids; $tableid is used for cache update. | ||
| 877 | # ------------------------------------------------ | ||
| 878 | sub records_add { | ||
| 879 | |||
| 880 | my ( $self, $table_path, $table_info, $tableid, $new_rids, $tier ) = @_; | ||
| 881 | |||
| 882 | return unless exists $table_info->{record_index}; | ||
| 883 | return unless ref($new_rids) eq 'ARRAY' && @$new_rids; | ||
| 884 | |||
| 885 | my @clean_rids = grep { defined $_ && $_ > 0 } @$new_rids; | ||
| 886 | return unless @clean_rids; | ||
| 887 | $new_rids = \@clean_rids; | ||
| 888 | |||
| 889 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 890 | my $key_name = "${pfx}keys"; | ||
| 891 | my $count_name = "${pfx}count"; | ||
| 892 | |||
| 893 | my $index_path = "$table_path.inx"; | ||
| 894 | my $idx_handle = $self->table_write($index_path); | ||
| 895 | if ($idx_handle) { | ||
| 896 | my $count; | ||
| 897 | if (!$pfx) { | ||
| 898 | my ($lastid) = $self->index_get( $index_path, "lastid", "raw" ); | ||
| 899 | $lastid //= 0; | ||
| 900 | |||
| 901 | # Fast-path O(1) Binary Append: | ||
| 902 | # If all new_rids are numeric, strictly ascending, and greater than current lastid, | ||
| 903 | # they are guaranteed not to exist in the table. | ||
| 904 | # Append them directly to the binary buffer without unpacking or deduplicating. | ||
| 905 | my $can_append = 1; | ||
| 906 | my $prev = $lastid; | ||
| 907 | for my $id (@$new_rids) { | ||
| 908 | unless ( defined $id && $id > $prev ) { | ||
| 909 | $can_append = 0; | ||
| 910 | last; | ||
| 911 | } | ||
| 912 | $prev = $id; | ||
| 913 | } | ||
| 914 | |||
| 915 | my $target = defined $tableid ? [ $index_path, $tableid ] : $index_path; | ||
| 916 | if ($can_append) { | ||
| 917 | my ($raw_keys) = $self->index_get( $index_path, "keys", "raw" ); | ||
| 918 | $raw_keys //= ''; | ||
| 919 | my $new_packed = $self->bin_encode($new_rids); | ||
| 920 | my $updated_keys = $raw_keys . $new_packed; | ||
| 921 | $self->index_put( $target, "keys", $updated_keys, "bin" ); | ||
| 922 | $count = int( bytes::length($updated_keys) / 8 ); | ||
| 923 | $lastid = $prev; | ||
| 924 | $self->index_put( $target, "lastid", $lastid, "raw" ); | ||
| 925 | $self->index_put( $target, "count", $count, "raw" ); | ||
| 926 | } | ||
| 927 | else { | ||
| 928 | # Non-sequential IDs (e.g. hole-filling or manual IDs): binary add and sort | ||
| 929 | my ($raw_keys) = $self->index_get( $index_path, "keys", "raw" ); | ||
| 930 | $raw_keys //= ''; | ||
| 931 | $raw_keys = $self->bin_add( $raw_keys, $new_rids ); | ||
| 932 | $raw_keys = $self->bin_sort( $raw_keys ); | ||
| 933 | $count = int( length($raw_keys) / 8 ); | ||
| 934 | $self->index_put( $target, "keys", $raw_keys, "bin" ); | ||
| 935 | $self->index_put( $target, "count", $count, "raw" ); | ||
| 936 | my @nums = sort { $b <=> $a } grep { defined $_ && $_ > 0 } @$new_rids; | ||
| 937 | if ( @nums && $nums[0] > $lastid ) { | ||
| 938 | $self->index_put( $target, "lastid", $nums[0], "raw" ); | ||
| 939 | $lastid = $nums[0]; | ||
| 940 | } | ||
| 941 | } | ||
| 942 | $self->table_close($index_path); | ||
| 943 | |||
| 944 | if ($tableid) { | ||
| 945 | $self->set_cache( $tableid, 'count', $count ); | ||
| 946 | $self->set_cache( $tableid, 'lastid', $lastid ); | ||
| 947 | $self->set_cache( $tableid, 'keys', undef ); | ||
| 948 | } | ||
| 949 | } | ||
| 950 | else { | ||
| 951 | # Tiered stream (A or B) | ||
| 952 | my ($raw_keys) = $self->index_get( $index_path, $key_name, "raw" ); | ||
| 953 | $raw_keys //= ''; | ||
| 954 | $raw_keys = $self->bin_add( $raw_keys, $new_rids ); | ||
| 955 | $raw_keys = $self->bin_sort( $raw_keys ); | ||
| 956 | $count = int( length($raw_keys) / 8 ); | ||
| 957 | $self->index_put( $index_path, $key_name, $raw_keys, "bin" ); | ||
| 958 | $self->index_put( $index_path, $count_name, $count, "raw" ); | ||
| 959 | $self->table_close($index_path); | ||
| 960 | } | ||
| 961 | } | ||
| 962 | |||
| 963 | if (!$pfx && $tableid) { | ||
| 964 | my @nums = sort { $b <=> $a } grep { defined $_ && $_ > 0 } @$new_rids; | ||
| 965 | if (@nums) { | ||
| 966 | my ($cached_lastid) = $self->get_cache( $tableid, "lastid" ); | ||
| 967 | $cached_lastid //= 0; | ||
| 968 | if ( $nums[0] > $cached_lastid ) { | ||
| 969 | $self->set_cache( $tableid, "lastid", $nums[0] ); | ||
| 970 | } | ||
| 971 | } | ||
| 972 | $self->set_cache( $tableid, "keys", undef ); | ||
| 973 | } | ||
| 974 | } | ||
| 975 | |||
| 976 | sub records_del { | ||
| 977 | |||
| 978 | my ( $self, $table_path, $table_info, $del_rids, $tableid, $tier ) = @_; | ||
| 979 | |||
| 980 | return unless exists $table_info->{record_index}; | ||
| 981 | return unless ref($del_rids) eq 'ARRAY' && @$del_rids; | ||
| 982 | |||
| 983 | my @clean_dels = grep { defined $_ && $_ > 0 } @$del_rids; | ||
| 984 | return unless @clean_dels; | ||
| 985 | $del_rids = \@clean_dels; | ||
| 986 | |||
| 987 | my $index_path = "$table_path.inx"; | ||
| 988 | return unless -e $index_path && $self->table_write($index_path); | ||
| 989 | |||
| 990 | my @tiers = ref($tier) eq 'ARRAY' ? @$tier : ( defined $tier && length($tier) ? ($tier) : (undef) ); | ||
| 991 | |||
| 992 | for my $t (@tiers) { | ||
| 993 | my $pfx = defined $t && $t =~ /^[AB]$/i ? uc("$t") . ":" : ""; | ||
| 994 | my $key_name = "${pfx}keys"; | ||
| 995 | my $count_name = "${pfx}count"; | ||
| 996 | |||
| 997 | my ($raw_keys) = $self->index_get( $index_path, $key_name, "raw" ); | ||
| 998 | my $count = 0; | ||
| 999 | if ( defined $raw_keys && length($raw_keys) > 0 ) { | ||
| 1000 | my $orig_len = length($raw_keys); | ||
| 1001 | $raw_keys = $self->bin_punch( $raw_keys, $del_rids ); | ||
| 1002 | $count = int( length($raw_keys) / 8 ); | ||
| 1003 | if ( length($raw_keys) != $orig_len ) { | ||
| 1004 | my $target = defined $tableid ? [ $index_path, $tableid ] : $index_path; | ||
| 1005 | if ($count > 0) { | ||
| 1006 | $self->index_put( $target, $key_name, $raw_keys, "bin" ); | ||
| 1007 | $self->index_put( $target, $count_name, $count, "raw" ); | ||
| 1008 | } | ||
| 1009 | else { | ||
| 1010 | $self->index_del( $target, $key_name ); | ||
| 1011 | $self->index_put( $target, $count_name, 0, "raw" ); | ||
| 1012 | } | ||
| 1013 | if (!$pfx && $tableid) { | ||
| 1014 | $self->set_cache( $tableid, 'count', $count ); | ||
| 1015 | $self->set_cache( $tableid, 'keys', undef ); | ||
| 1016 | } | ||
| 1017 | } | ||
| 1018 | } | ||
| 1019 | } | ||
| 1020 | $self->table_close($index_path); | ||
| 1021 | } | ||
| 1022 | |||
| 1023 | # ------------------------------------------------ | ||
| 1024 | # URL Slug Lifecycle Methods (.slg) | ||
| 1025 | # ------------------------------------------------ | ||
| 1026 | |||
| 1027 | sub _build_slug { | ||
| 1028 | my ( $self, $table_info, $record ) = @_; | ||
| 1029 | |||
| 1030 | return '' unless ref($table_info) eq 'HASH' && $table_info->{slug_block}; | ||
| 1031 | return '' unless ref($record) eq 'ARRAY'; | ||
| 1032 | |||
| 1033 | $self->{slug_max_len} ||= 64; | ||
| 1034 | |||
| 1035 | my $rw_link = ''; | ||
| 1036 | my $fields = [ @{$record} ]; | ||
| 1037 | my $slug_blocks = ref($table_info->{slug_block}) eq 'ARRAY' ? $table_info->{slug_block} : [ $table_info->{slug_block} ]; | ||
| 1038 | |||
| 1039 | for my $i ( @$slug_blocks ) { | ||
| 1040 | $fields->[$i] =~ s/[;,].*// if defined $fields->[$i]; | ||
| 1041 | my $blok = $table_info->{blocks}->[$i] || {}; | ||
| 1042 | if ( defined $blok->{rdbm} && ref( $blok->{rdbm} ) ne 'HASH' && $blok->{rdbm} =~ /([\w]+)[;:,]([\d]+)/ ) { | ||
| 1043 | $blok->{rdbm} = { table => $1, display => $2 }; | ||
| 1044 | } | ||
| 1045 | if ( ref( $blok->{rdbm} ) eq 'HASH' && $blok->{rdbm}{table} ) { | ||
| 1046 | my ( $rdbm_table, $rdbm_blok ) = ( $blok->{rdbm}{table}, $blok->{rdbm}{display} // 2 ); | ||
| 1047 | my $rdbm_id = $fields->[$i]; | ||
| 1048 | if ( defined $rdbm_id && length $rdbm_id ) { | ||
| 1049 | if ( !exists $self->{_rdbm_memo}{$rdbm_table}{$rdbm_id} ) { | ||
| 1050 | my @recs = $self->get_cache( $rdbm_table, $rdbm_id ); | ||
| 1051 | if ( !@recs ) { | ||
| 1052 | my $r_path = $self->table_path($rdbm_table) . "." . ( $self->{db_ext} || 'db' ); | ||
| 1053 | @recs = $self->table_readid( $r_path, $rdbm_id ); | ||
| 1054 | $self->set_cache( $rdbm_table, $rdbm_id, \@recs ) if @recs; | ||
| 1055 | } | ||
| 1056 | $self->{_rdbm_memo}{$rdbm_table}{$rdbm_id} = ( @recs && defined $recs[$rdbm_blok] ) ? $recs[$rdbm_blok] : ''; | ||
| 1057 | } | ||
| 1058 | my $resolved = $self->{_rdbm_memo}{$rdbm_table}{$rdbm_id}; | ||
| 1059 | $fields->[$i] = $resolved if length $resolved; | ||
| 1060 | } | ||
| 1061 | else { | ||
| 1062 | my $rdbm_info = $self->table_info($rdbm_table); | ||
| 1063 | $fields->[$i] = $rdbm_info->{name} if $rdbm_info; | ||
| 1064 | } | ||
| 1065 | } | ||
| 1066 | |||
| 1067 | # ascii and cleaned representation | ||
| 1068 | $fields->[$i] = lc( $self->to_ascii( $fields->[$i] ) ); | ||
| 1069 | $fields->[$i] =~ s/[^a-z0-9]+/-/g; | ||
| 1070 | if ( length( $fields->[$i] ) > $self->{slug_max_len} ) { | ||
| 1071 | $fields->[$i] = substr( $fields->[$i], 0, $self->{slug_max_len} ); | ||
| 1072 | } | ||
| 1073 | $fields->[$i] =~ s/^\-|\-$//; | ||
| 1074 | $fields->[$i] or next; | ||
| 1075 | $rw_link and $rw_link .= "/"; | ||
| 1076 | $rw_link .= $fields->[$i]; | ||
| 1077 | } | ||
| 1078 | |||
| 1079 | return $rw_link; | ||
| 1080 | } | ||
| 1081 | |||
| 1082 | # $adb->slug_add( $table_path, $table_info, $tableid, \@records ); | ||
| 1083 | # ------------------------------------------------ | ||
| 1084 | sub slug_add { | ||
| 1085 | my ( $self, $table_path, $table_info, $tableid, $records ) = @_; | ||
| 1086 | |||
| 1087 | return unless ref($table_info) eq 'HASH' && $table_info->{slug_block}; | ||
| 1088 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 1089 | |||
| 1090 | $tableid //= $table_info->{name}; | ||
| 1091 | if ( !$tableid && defined $table_path ) { | ||
| 1092 | ($tableid) = $table_path =~ m{([^/\\:]+)$}; | ||
| 1093 | } | ||
| 1094 | |||
| 1095 | my @recs = ref( $records->[0] ) eq 'ARRAY' ? @$records : ($records); | ||
| 1096 | |||
| 1097 | my @staged; | ||
| 1098 | my @keys_to_fetch; | ||
| 1099 | for my $rec (@recs) { | ||
| 1100 | next unless ref($rec) eq 'ARRAY' && @$rec; | ||
| 1101 | my $rid = $rec->[0]; | ||
| 1102 | next unless defined $rid && $rid ne ''; | ||
| 1103 | my $slug = $self->_build_slug( $table_info, $rec ); | ||
| 1104 | next unless defined $slug && length $slug; | ||
| 1105 | push @staged, [ $rec, $slug ]; | ||
| 1106 | push @keys_to_fetch, "1:$slug"; | ||
| 1107 | } | ||
| 1108 | return unless @staged; | ||
| 1109 | |||
| 1110 | my $slg_path = "${table_path}.slg"; | ||
| 1111 | my $opened = 0; | ||
| 1112 | if ( !$self->{_db}->{$slg_path} ) { | ||
| 1113 | $self->table_write($slg_path) or do { | ||
| 1114 | $self->transact_error( $slg_path, "cannot open" ); | ||
| 1115 | return; | ||
| 1116 | }; | ||
| 1117 | $opened = 1; | ||
| 1118 | } | ||
| 1119 | |||
| 1120 | my $existing = @keys_to_fetch ? $self->recs_get( $slg_path, @keys_to_fetch ) : {}; | ||
| 1121 | my %batch_claimed; | ||
| 1122 | my @to_put; | ||
| 1123 | |||
| 1124 | for my $item (@staged) { | ||
| 1125 | my ( $rec, $slug ) = @$item; | ||
| 1126 | my $rid = $rec->[0]; | ||
| 1127 | |||
| 1128 | my $existing_rid = $batch_claimed{"1:$slug"} // $existing->{"1:$slug"}; | ||
| 1129 | if ( defined $existing_rid && "$existing_rid" ne "$rid" ) { | ||
| 1130 | $slug .= "-$rid"; | ||
| 1131 | } | ||
| 1132 | $batch_claimed{"1:$slug"} = $rid; | ||
| 1133 | |||
| 1134 | push @to_put, [ "1:$slug", $rid ], [ "0:$rid", $slug ]; | ||
| 1135 | } | ||
| 1136 | |||
| 1137 | $self->recs_put( [ $slg_path, $tableid ], @to_put ) if @to_put; | ||
| 1138 | |||
| 1139 | if ($opened) { | ||
| 1140 | $self->table_close($slg_path); | ||
| 1141 | } | ||
| 1142 | |||
| 1143 | return 1; | ||
| 1144 | } | ||
| 1145 | |||
| 1146 | # $adb->slug_del( $table_path, $table_info, $tableid, \@records_or_rids ); | ||
| 1147 | # ------------------------------------------------ | ||
| 1148 | sub slug_del { | ||
| 1149 | my ( $self, $table_path, $table_info, $tableid, $items ) = @_; | ||
| 1150 | |||
| 1151 | return unless ref($table_info) eq 'HASH' && $table_info->{slug_block}; | ||
| 1152 | return unless ref($items) eq 'ARRAY' && @$items; | ||
| 1153 | |||
| 1154 | $tableid //= $table_info->{name}; | ||
| 1155 | if ( !$tableid && defined $table_path ) { | ||
| 1156 | ($tableid) = $table_path =~ m{([^/\\:]+)$}; | ||
| 1157 | } | ||
| 1158 | |||
| 1159 | my @rids; | ||
| 1160 | for my $it (@$items) { | ||
| 1161 | if ( ref($it) eq 'ARRAY' ) { | ||
| 1162 | push @rids, $it->[0] if defined $it->[0] && $it->[0] ne ''; | ||
| 1163 | } | ||
| 1164 | elsif ( defined $it && $it ne '' ) { | ||
| 1165 | push @rids, $it; | ||
| 1166 | } | ||
| 1167 | } | ||
| 1168 | return unless @rids; | ||
| 1169 | |||
| 1170 | my $slg_path = "${table_path}.slg"; | ||
| 1171 | return unless -e $slg_path || $self->{_db}->{$slg_path}; | ||
| 1172 | |||
| 1173 | my $opened = 0; | ||
| 1174 | if ( !$self->{_db}->{$slg_path} ) { | ||
| 1175 | $self->table_write($slg_path) or do { | ||
| 1176 | $self->transact_error( $slg_path, "cannot open" ); | ||
| 1177 | return; | ||
| 1178 | }; | ||
| 1179 | $opened = 1; | ||
| 1180 | } | ||
| 1181 | |||
| 1182 | my @zero_keys = map { "0:$_" } @rids; | ||
| 1183 | my $slug_vals = $self->recs_get( $slg_path, @zero_keys ); | ||
| 1184 | |||
| 1185 | my @to_del; | ||
| 1186 | for my $rid (@rids) { | ||
| 1187 | push @to_del, "0:$rid"; | ||
| 1188 | my $slug = $slug_vals->{"0:$rid"}; | ||
| 1189 | push @to_del, "1:$slug" if defined $slug && length $slug; | ||
| 1190 | } | ||
| 1191 | |||
| 1192 | $self->recs_del( [ $slg_path, $tableid ], @to_del ) if @to_del; | ||
| 1193 | |||
| 1194 | if ($opened) { | ||
| 1195 | $self->table_close($slg_path); | ||
| 1196 | } | ||
| 1197 | |||
| 1198 | return 1; | ||
| 1199 | } | ||
| 1200 | |||
| 1201 | # $adb->slug_modify( $table_path, $table_info, $tableid, \@pairs ); | ||
| 1202 | # ------------------------------------------------ | ||
| 1203 | sub slug_modify { | ||
| 1204 | my ( $self, $table_path, $table_info, $tableid, $pairs ) = @_; | ||
| 1205 | |||
| 1206 | return unless ref($table_info) eq 'HASH' && $table_info->{slug_block}; | ||
| 1207 | return unless ref($pairs) eq 'ARRAY' && @$pairs; | ||
| 1208 | |||
| 1209 | $tableid //= $table_info->{name}; | ||
| 1210 | if ( !$tableid && defined $table_path ) { | ||
| 1211 | ($tableid) = $table_path =~ m{([^/\\:]+)$}; | ||
| 1212 | } | ||
| 1213 | |||
| 1214 | my $slug_blocks = ref($table_info->{slug_block}) eq 'ARRAY' ? $table_info->{slug_block} : [ $table_info->{slug_block} ]; | ||
| 1215 | my @changed_pairs; | ||
| 1216 | for my $pair (@$pairs) { | ||
| 1217 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 1218 | next unless defined $rid && $rid ne ''; | ||
| 1219 | next unless ref($new_rec) eq 'ARRAY'; | ||
| 1220 | |||
| 1221 | my $changed = 0; | ||
| 1222 | if ( ref($old_rec) eq 'ARRAY' && @$old_rec ) { | ||
| 1223 | for my $sb (@$slug_blocks) { | ||
| 1224 | my $ov = $old_rec->[$sb] // ''; | ||
| 1225 | my $nv = $new_rec->[$sb] // ''; | ||
| 1226 | if ( $ov ne $nv ) { | ||
| 1227 | $changed = 1; | ||
| 1228 | last; | ||
| 1229 | } | ||
| 1230 | } | ||
| 1231 | } | ||
| 1232 | else { | ||
| 1233 | $changed = 1; | ||
| 1234 | } | ||
| 1235 | push @changed_pairs, $pair if $changed; | ||
| 1236 | } | ||
| 1237 | return unless @changed_pairs; | ||
| 1238 | |||
| 1239 | my $slg_path = "${table_path}.slg"; | ||
| 1240 | my $opened = 0; | ||
| 1241 | if ( !$self->{_db}->{$slg_path} ) { | ||
| 1242 | $self->table_write($slg_path) or do { | ||
| 1243 | $self->transact_error( $slg_path, "cannot open" ); | ||
| 1244 | return; | ||
| 1245 | }; | ||
| 1246 | $opened = 1; | ||
| 1247 | } | ||
| 1248 | |||
| 1249 | my @zero_keys = map { "0:" . $_->[0] } @changed_pairs; | ||
| 1250 | my $old_slug_map = $self->recs_get( $slg_path, @zero_keys ); | ||
| 1251 | |||
| 1252 | my @to_del; | ||
| 1253 | my @to_put; | ||
| 1254 | my %batch_claimed; | ||
| 1255 | |||
| 1256 | for my $pair (@changed_pairs) { | ||
| 1257 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 1258 | my $old_slug = $old_slug_map->{"0:$rid"}; | ||
| 1259 | my $new_slug = $self->_build_slug( $table_info, $new_rec ); | ||
| 1260 | next unless defined $new_slug && length $new_slug; | ||
| 1261 | |||
| 1262 | my $existing_rid = $batch_claimed{"1:$new_slug"}; | ||
| 1263 | if ( !defined $existing_rid ) { | ||
| 1264 | my $got = $self->recs_get( $slg_path, "1:$new_slug" ); | ||
| 1265 | $existing_rid = $got->{"1:$new_slug"}; | ||
| 1266 | } | ||
| 1267 | if ( defined $existing_rid && "$existing_rid" ne "$rid" ) { | ||
| 1268 | $new_slug .= "-$rid"; | ||
| 1269 | } | ||
| 1270 | $batch_claimed{"1:$new_slug"} = $rid; | ||
| 1271 | |||
| 1272 | if ( defined $old_slug && length $old_slug && $old_slug ne $new_slug ) { | ||
| 1273 | push @to_del, "1:$old_slug"; | ||
| 1274 | } | ||
| 1275 | |||
| 1276 | push @to_put, [ "1:$new_slug", $rid ], [ "0:$rid", $new_slug ]; | ||
| 1277 | } | ||
| 1278 | |||
| 1279 | $self->recs_del( [ $slg_path, $tableid ], @to_del ) if @to_del; | ||
| 1280 | $self->recs_put( [ $slg_path, $tableid ], @to_put ) if @to_put; | ||
| 1281 | |||
| 1282 | if ($opened) { | ||
| 1283 | $self->table_close($slg_path); | ||
| 1284 | } | ||
| 1285 | |||
| 1286 | return 1; | ||
| 1287 | } | ||
| 1288 | |||
| 1289 | # my $rw_link = $adb->set_slug($table, $record); | ||
| 1290 | # my $rw_link = $adb->set_slug($table, $record, 1); | ||
| 1291 | # ------------------------------------------------ | ||
| 1292 | sub set_slug { | ||
| 1293 | |||
| 1294 | my ( $self, $table, $record, $write, $alt_path ) = @_; | ||
| 1295 | |||
| 1296 | $table or return; | ||
| 1297 | (defined $record && ref($record) eq "ARRAY") or return; | ||
| 1298 | my $table_info = ref($table) eq 'HASH' ? $table : $self->table_info($table); | ||
| 1299 | $table_info->{slug_block} or return; | ||
| 1300 | |||
| 1301 | my $table_path = $alt_path // ( ref($table) eq 'HASH' ? ( $table_info->{path} // $self->table_path($table_info->{name}) ) : $self->table_path($table) ); | ||
| 1302 | my $tableid = ref($table) eq 'HASH' ? $table_info->{name} : $table; | ||
| 1303 | |||
| 1304 | my $rw_link = $self->_build_slug( $table_info, $record ); | ||
| 1305 | |||
| 1306 | if ($write) { | ||
| 1307 | $self->slug_add( $table_path, $table_info, $tableid, [ $record ] ); | ||
| 1308 | my $rid = $record->[0]; | ||
| 1309 | my $slg_path = "${table_path}.slg"; | ||
| 1310 | if ( defined $rid && -e $slg_path ) { | ||
| 1311 | if ( $self->table_read($slg_path) ) { | ||
| 1312 | my $val = $self->recs_get( $slg_path, "0:$rid" )->{"0:$rid"}; | ||
| 1313 | $rw_link = $val if defined $val; | ||
| 1314 | $self->table_close($slg_path); | ||
| 1315 | } | ||
| 1316 | } | ||
| 1317 | } | ||
| 1318 | |||
| 1319 | return $rw_link; | ||
| 1320 | } | ||
| 1321 | |||
| 1322 | # my ($links) = $adb->get_slug($table, 0, @records_ids); | ||
| 1323 | # my ($links) = $adb->get_slug($table, 1, @records_ids); | ||
| 1324 | # ------------------------------------------------ | ||
| 1325 | sub get_slug { | ||
| 1326 | |||
| 1327 | my ( $self, $table, $type, @records ) = @_; | ||
| 1328 | |||
| 1329 | my $links = {}; | ||
| 1330 | |||
| 1331 | # verifications | ||
| 1332 | $table or return {}; | ||
| 1333 | scalar @records or return {}; | ||
| 1334 | $type //= 0; | ||
| 1335 | |||
| 1336 | # To get slug value, first the table_path | ||
| 1337 | my $table_info = $self->table_info($table); | ||
| 1338 | return {} unless $table_info && $table_info->{slug_block}; | ||
| 1339 | |||
| 1340 | my $use_ramdisk = $table_info ? ( $table_info->{use_ramdisk} // $table_info->{use_cache} // 0 ) : 0; | ||
| 1341 | if ($use_ramdisk) { | ||
| 1342 | $self->ramdisk_ensure($table); | ||
| 1343 | } | ||
| 1344 | my $table_path = $use_ramdisk ? $self->ramdisk_path($table) : $self->table_path($table); | ||
| 1345 | |||
| 1346 | my $unified_slg = "${table_path}.slg"; | ||
| 1347 | if ( -e $unified_slg ) { | ||
| 1348 | $self->table_read($unified_slg) or return {}; | ||
| 1349 | my @rids = map { | ||
| 1350 | my $rid = ref($_) eq "ARRAY" ? $_->[0] : $_; | ||
| 1351 | $rid =~ s/^\///; | ||
| 1352 | $rid =~ s/\/$//; | ||
| 1353 | $rid; | ||
| 1354 | } @records; | ||
| 1355 | my @prefixed_keys = map { "$type:$_" } @rids; | ||
| 1356 | my $vals = $self->recs_get( $unified_slg, @prefixed_keys ); | ||
| 1357 | for my $rid (@rids) { | ||
| 1358 | $links->{$rid} = $vals->{"$type:$rid"}; | ||
| 1359 | } | ||
| 1360 | $self->table_close($unified_slg); | ||
| 1361 | } | ||
| 1362 | |||
| 1363 | return $links; | ||
| 1364 | } | ||
| 1365 | |||
| 1366 | # ------------------------------------------------ | ||
| 1367 | # Sorting Index Lifecycle Methods (.inx) | ||
| 1368 | # ------------------------------------------------ | ||
| 1369 | |||
| 1370 | sub sort_add { | ||
| 1371 | my ( $self, $table_path, $table_info, $records, $tier ) = @_; | ||
| 1372 | |||
| 1373 | return unless exists $table_info->{sort_block}; | ||
| 1374 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 1375 | |||
| 1376 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 1377 | |||
| 1378 | my ($tableid) = ( $table_path =~ /([^\\\/]+)$/ ); | ||
| 1379 | my $index_path = "${table_path}.inx"; | ||
| 1380 | |||
| 1381 | $self->flock_open( $tableid, "write", "records" ); | ||
| 1382 | unless ( $self->table_write($index_path) ) { | ||
| 1383 | $self->flock_close( $tableid, "records" ); | ||
| 1384 | return; | ||
| 1385 | } | ||
| 1386 | |||
| 1387 | foreach my $cfg ( @{ $table_info->{sort_block} } ) { | ||
| 1388 | my ( $blk, $type, $len ); | ||
| 1389 | if ( ref($cfg) eq 'HASH' ) { | ||
| 1390 | $blk = $cfg->{blk} // $cfg->{block} // 0; | ||
| 1391 | $type = $cfg->{type}; | ||
| 1392 | $len = $cfg->{len} // 8; | ||
| 1393 | } | ||
| 1394 | else { | ||
| 1395 | $blk = $cfg; | ||
| 1396 | $type = undef; | ||
| 1397 | $len = 8; | ||
| 1398 | } | ||
| 1399 | $blk = $self->resolve_block_idx( $tableid, $blk ) if $tableid; | ||
| 1400 | |||
| 1401 | # Resolve type from schema blocks if not explicitly set | ||
| 1402 | if ( ( !defined $type || $type eq '' || $type eq 'auto' ) && $table_info->{blocks} ) { | ||
| 1403 | if ( ref($table_info->{blocks}) eq 'ARRAY' && ref($table_info->{blocks}[$blk]) eq 'HASH' ) { | ||
| 1404 | $type = $table_info->{blocks}[$blk]{type}; | ||
| 1405 | } | ||
| 1406 | } | ||
| 1407 | $type ||= 'string'; | ||
| 1408 | |||
| 1409 | my $sort_key_name = "$pfx$blk:keys"; | ||
| 1410 | my ( undef, @keys ) = $self->index_get( $index_path, $sort_key_name, "ids" ); | ||
| 1411 | my %map; | ||
| 1412 | if (@keys) { | ||
| 1413 | my @norm_keys = map { "$pfx$blk:$_" } @keys; | ||
| 1414 | my $norm_map = $self->index_get( $index_path, \@norm_keys, "raw" ); | ||
| 1415 | if ($norm_map) { | ||
| 1416 | for my $k (@keys) { | ||
| 1417 | my $v = $norm_map->{"$pfx$blk:$k"}; | ||
| 1418 | $map{$k} = $v if defined $v; | ||
| 1419 | } | ||
| 1420 | } | ||
| 1421 | } | ||
| 1422 | |||
| 1423 | my %batch_put; | ||
| 1424 | foreach my $rec (@$records) { | ||
| 1425 | my $rid = $rec->[0]; | ||
| 1426 | next unless defined $rid && $rid ne ''; | ||
| 1427 | next if exists $map{$rid}; # Duplicate prevention | ||
| 1428 | |||
| 1429 | my $norm = $self->normalize_sort_key( $rec->[$blk], $type, $len ); | ||
| 1430 | $map{$rid} = $norm; | ||
| 1431 | $batch_put{"$pfx$blk:$rid"} = $norm; | ||
| 1432 | } | ||
| 1433 | |||
| 1434 | if (%batch_put) { | ||
| 1435 | my ($existing_range) = $self->index_get( $index_path, "$pfx$blk:vals", 'raw' ); | ||
| 1436 | my %uniq_vals; | ||
| 1437 | if (defined $existing_range && length($existing_range)) { | ||
| 1438 | $existing_range = $self->utf_decode($existing_range); | ||
| 1439 | $uniq_vals{$_} = 1 for split /\t/, $existing_range; | ||
| 1440 | } | ||
| 1441 | foreach my $rec (@$records) { | ||
| 1442 | my $v = $rec->[$blk]; | ||
| 1443 | $v = $self->utf_decode($v) if defined $v; | ||
| 1444 | $uniq_vals{$v} = 1 if defined $v && $v ne ''; | ||
| 1445 | } | ||
| 1446 | my $is_num = 1; | ||
| 1447 | for my $k ( keys %uniq_vals ) { | ||
| 1448 | if ( $k !~ /^-?[0-9]+(?:\.[0-9]+)?$/ ) { | ||
| 1449 | $is_num = 0; | ||
| 1450 | last; | ||
| 1451 | } | ||
| 1452 | } | ||
| 1453 | my @sorted_vals = $is_num ? ( sort { $a <=> $b } keys %uniq_vals ) : ( sort { $a cmp $b } keys %uniq_vals ); | ||
| 1454 | $batch_put{"$pfx$blk:vals"} = join( "\t", @sorted_vals ) if @sorted_vals; | ||
| 1455 | |||
| 1456 | my @sorted_keys = grep { defined $_ && $_ > 0 } sort { ( ( $map{$a} // '' ) cmp ( $map{$b} // '' ) ) || ( $a <=> $b ) } keys %map; | ||
| 1457 | $self->index_put( $index_path, $sort_key_name, \@sorted_keys, "ids" ); | ||
| 1458 | $self->index_put( $index_path, \%batch_put, "raw" ); | ||
| 1459 | } | ||
| 1460 | } | ||
| 1461 | |||
| 1462 | $self->table_close($index_path); | ||
| 1463 | $self->flock_close( $tableid, "records" ); | ||
| 1464 | } | ||
| 1465 | |||
| 1466 | sub sort_modify { | ||
| 1467 | my ( $self, $table_path, $table_info, $pairs, $tier ) = @_; | ||
| 1468 | |||
| 1469 | return unless exists $table_info->{sort_block}; | ||
| 1470 | return unless ref($pairs) eq 'ARRAY' && @$pairs; | ||
| 1471 | |||
| 1472 | my $pfx = defined $tier && $tier =~ /^[AB]$/i ? uc("$tier") . ":" : ""; | ||
| 1473 | |||
| 1474 | my ($tableid) = ( $table_path =~ /([^\\\/]+)$/ ); | ||
| 1475 | my $index_path = "${table_path}.inx"; | ||
| 1476 | |||
| 1477 | $self->flock_open( $tableid, "write", "records" ); | ||
| 1478 | unless ( $self->table_write($index_path) ) { | ||
| 1479 | $self->flock_close( $tableid, "records" ); | ||
| 1480 | return; | ||
| 1481 | } | ||
| 1482 | |||
| 1483 | foreach my $cfg ( @{ $table_info->{sort_block} } ) { | ||
| 1484 | my ( $blk, $type, $len ); | ||
| 1485 | if ( ref($cfg) eq 'HASH' ) { | ||
| 1486 | $blk = $cfg->{blk} // $cfg->{block} // 0; | ||
| 1487 | $type = $cfg->{type}; | ||
| 1488 | $len = $cfg->{len} // 8; | ||
| 1489 | } | ||
| 1490 | else { | ||
| 1491 | $blk = $cfg; | ||
| 1492 | $type = undef; | ||
| 1493 | $len = 8; | ||
| 1494 | } | ||
| 1495 | $blk = $self->resolve_block_idx( $tableid, $blk ) if $tableid; | ||
| 1496 | |||
| 1497 | # Resolve type from schema blocks if not explicitly set | ||
| 1498 | if ( ( !defined $type || $type eq '' || $type eq 'auto' ) && $table_info->{blocks} ) { | ||
| 1499 | if ( ref($table_info->{blocks}) eq 'ARRAY' && ref($table_info->{blocks}[$blk]) eq 'HASH' ) { | ||
| 1500 | $type = $table_info->{blocks}[$blk]{type}; | ||
| 1501 | } | ||
| 1502 | } | ||
| 1503 | $type ||= 'string'; | ||
| 1504 | |||
| 1505 | my $sort_key_name = "$pfx$blk:keys"; | ||
| 1506 | my ( undef, @keys ) = $self->index_get( $index_path, $sort_key_name, "ids" ); | ||
| 1507 | my %map; | ||
| 1508 | if (@keys) { | ||
| 1509 | my @norm_keys = map { "$pfx$blk:$_" } @keys; | ||
| 1510 | my $norm_map = $self->index_get( $index_path, \@norm_keys, "raw" ); | ||
| 1511 | if ($norm_map) { | ||
| 1512 | for my $k (@keys) { | ||
| 1513 | my $v = $norm_map->{"$pfx$blk:$k"}; | ||
| 1514 | $map{$k} = $v if defined $v; | ||
| 1515 | } | ||
| 1516 | } | ||
| 1517 | } | ||
| 1518 | |||
| 1519 | my %batch_put; | ||
| 1520 | my $modified = 0; | ||
| 1521 | foreach my $pair (@$pairs) { | ||
| 1522 | my ( $rid, $old_rec, $new_rec ) = @$pair; | ||
| 1523 | |||
| 1524 | my $old_norm = $map{$rid} // ''; | ||
| 1525 | my $new_norm = $self->normalize_sort_key( $new_rec->[$blk], $type, $len ); | ||
| 1526 | |||
| 1527 | next if $old_norm eq $new_norm; | ||
| 1528 | |||
| 1529 | $map{$rid} = $new_norm; | ||
| 1530 | $batch_put{"$pfx$blk:$rid"} = $new_norm; | ||
| 1531 | $modified = 1; | ||
| 1532 | } | ||
| 1533 | |||
| 1534 | if ($modified) { | ||
| 1535 | my ($existing_range) = $self->index_get( $index_path, "$pfx$blk:vals", 'raw' ); | ||
| 1536 | my %uniq_vals; | ||
| 1537 | if (defined $existing_range && length($existing_range)) { | ||
| 1538 | $existing_range = $self->utf_decode($existing_range); | ||
| 1539 | $uniq_vals{$_} = 1 for split /\t/, $existing_range; | ||
| 1540 | } | ||
| 1541 | my $field_path = "${table_path}.fld"; | ||
| 1542 | foreach my $pair (@$pairs) { | ||
| 1543 | my $old_v = defined $pair->[1]->[$blk] ? $self->utf_decode($pair->[1]->[$blk]) : undef; | ||
| 1544 | my $new_v = defined $pair->[2]->[$blk] ? $self->utf_decode($pair->[2]->[$blk]) : undef; | ||
| 1545 | $uniq_vals{$new_v} = 1 if defined $new_v && $new_v ne ''; | ||
| 1546 | if ( defined $old_v && $old_v ne '' && ( !defined $new_v || $new_v ne $old_v ) ) { | ||
| 1547 | if ( -e $field_path ) { | ||
| 1548 | my $old_raw = $self->utf_encode($old_v); | ||
| 1549 | my ($rem) = $self->index_get( $field_path, "$pfx$blk:$old_raw", 'raw' ); | ||
| 1550 | if ( !defined $rem || length($rem) < 8 ) { | ||
| 1551 | delete $uniq_vals{$old_v}; | ||
| 1552 | } | ||
| 1553 | } | ||
| 1554 | } | ||
| 1555 | } | ||
| 1556 | my $is_num = ( $type eq 'num' || $type eq 'decimal' ) ? 1 : 0; | ||
| 1557 | if ( !$is_num && %uniq_vals ) { | ||
| 1558 | $is_num = 1; | ||
| 1559 | for my $k ( keys %uniq_vals ) { | ||
| 1560 | if ( $k !~ /^-?[0-9]+(?:\.[0-9]+)?$/ ) { | ||
| 1561 | $is_num = 0; | ||
| 1562 | last; | ||
| 1563 | } | ||
| 1564 | } | ||
| 1565 | } | ||
| 1566 | my @sorted_vals = $is_num ? ( sort { $a <=> $b } keys %uniq_vals ) : ( sort { $a cmp $b } keys %uniq_vals ); | ||
| 1567 | if (@sorted_vals) { | ||
| 1568 | $batch_put{"$pfx$blk:vals"} = join( "\t", @sorted_vals ); | ||
| 1569 | } | ||
| 1570 | else { | ||
| 1571 | $self->index_del( $index_path, "$pfx$blk:vals" ); | ||
| 1572 | } | ||
| 1573 | |||
| 1574 | my @sorted_keys = grep { defined $_ && $_ > 0 } sort { ( ( $map{$a} // '' ) cmp ( $map{$b} // '' ) ) || ( $a <=> $b ) } keys %map; | ||
| 1575 | $self->index_put( $index_path, $sort_key_name, \@sorted_keys, "ids" ); | ||
| 1576 | $self->index_put( $index_path, \%batch_put, "raw" ) if %batch_put; | ||
| 1577 | } | ||
| 1578 | |||
| 1579 | } | ||
| 1580 | |||
| 1581 | $self->table_close($index_path); | ||
| 1582 | $self->flock_close( $tableid, "records" ); | ||
| 1583 | } | ||
| 1584 | |||
| 1585 | sub sort_del { | ||
| 1586 | my ( $self, $table_path, $table_info, $records, $tier ) = @_; | ||
| 1587 | |||
| 1588 | return unless exists $table_info->{sort_block}; | ||
| 1589 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 1590 | |||
| 1591 | my ($tableid) = ( $table_path =~ /([^\\\/]+)$/ ); | ||
| 1592 | my $index_path = "${table_path}.inx"; | ||
| 1593 | return unless -e $index_path; | ||
| 1594 | |||
| 1595 | my @tiers = ref($tier) eq 'ARRAY' ? @$tier : ( defined $tier && length($tier) ? ($tier) : (undef) ); | ||
| 1596 | |||
| 1597 | $self->flock_open( $tableid, "write", "records" ); | ||
| 1598 | if ( $self->table_write($index_path) ) { | ||
| 1599 | my @del_ids = map { $_->[0] } grep { defined $_->[0] } @$records; | ||
| 1600 | my %del_map = map { $_ => 1 } @del_ids; | ||
| 1601 | |||
| 1602 | for my $t (@tiers) { | ||
| 1603 | my $pfx = defined $t && $t =~ /^[AB]$/i ? uc("$t") . ":" : ""; | ||
| 1604 | |||
| 1605 | foreach my $cfg ( @{ $table_info->{sort_block} } ) { | ||
| 1606 | my $blk = ref($cfg) eq 'HASH' ? ( $cfg->{blk} // $cfg->{block} // 0 ) : $cfg; | ||
| 1607 | $blk = $self->resolve_block_idx( $tableid, $blk ) if $tableid; | ||
| 1608 | my $type = ref($cfg) eq 'HASH' ? $cfg->{type} : undef; | ||
| 1609 | if ( ( !defined $type || $type eq '' || $type eq 'auto' ) && $table_info->{blocks} ) { | ||
| 1610 | if ( ref($table_info->{blocks}) eq 'ARRAY' && ref($table_info->{blocks}[$blk]) eq 'HASH' ) { | ||
| 1611 | $type = $table_info->{blocks}[$blk]{type}; | ||
| 1612 | } | ||
| 1613 | } | ||
| 1614 | $type ||= 'string'; | ||
| 1615 | |||
| 1616 | my $sort_key_name = "$pfx$blk:keys"; | ||
| 1617 | |||
| 1618 | my ($raw_keys) = $self->index_get( $index_path, $sort_key_name, "raw" ); | ||
| 1619 | if ( defined $raw_keys && length($raw_keys) >= 8 && length($raw_keys) % 8 == 0 ) { | ||
| 1620 | my $orig_len = length($raw_keys); | ||
| 1621 | $raw_keys = $self->bin_punch( $raw_keys, \@del_ids ); | ||
| 1622 | if ( length($raw_keys) != $orig_len ) { | ||
| 1623 | if ( length($raw_keys) > 0 ) { | ||
| 1624 | $self->index_put( $index_path, $sort_key_name, $raw_keys, "bin" ); | ||
| 1625 | } | ||
| 1626 | else { | ||
| 1627 | $self->index_del( $index_path, $sort_key_name ); | ||
| 1628 | $self->index_del( $index_path, "$pfx$blk:vals" ); | ||
| 1629 | } | ||
| 1630 | } | ||
| 1631 | } | ||
| 1632 | else { | ||
| 1633 | my ( undef, @keys ) = $self->index_get( $index_path, $sort_key_name ); | ||
| 1634 | @keys = grep { !$del_map{$_} } @keys; | ||
| 1635 | if (@keys) { | ||
| 1636 | $self->index_put( $index_path, $sort_key_name, \@keys, "ids" ); | ||
| 1637 | } | ||
| 1638 | else { | ||
| 1639 | $self->index_del( $index_path, $sort_key_name ); | ||
| 1640 | $self->index_del( $index_path, "$pfx$blk:vals" ); | ||
| 1641 | } | ||
| 1642 | } | ||
| 1643 | |||
| 1644 | # Check and prune deleted values from $pfx$blk:vals if no remaining keys in .fld | ||
| 1645 | my $field_path = "${table_path}.fld"; | ||
| 1646 | if ( -e $field_path ) { | ||
| 1647 | my ($existing_vals) = $self->index_get( $index_path, "$pfx$blk:vals", 'raw' ); | ||
| 1648 | if ( defined $existing_vals && length($existing_vals) ) { | ||
| 1649 | $existing_vals = $self->utf_decode($existing_vals); | ||
| 1650 | my %uniq_vals = map { $_ => 1 } split /\t/, $existing_vals; | ||
| 1651 | my $vals_changed = 0; | ||
| 1652 | foreach my $rec (@$records) { | ||
| 1653 | my $v = defined $rec->[$blk] ? $self->utf_decode($rec->[$blk]) : undef; | ||
| 1654 | next unless defined $v && $v ne ''; | ||
| 1655 | if ( exists $uniq_vals{$v} ) { | ||
| 1656 | my $raw_v = $self->utf_encode($v); | ||
| 1657 | my ($rem) = $self->index_get( $field_path, "$pfx$blk:$raw_v", 'raw' ); | ||
| 1658 | if ( !defined $rem || length($rem) < 8 ) { | ||
| 1659 | delete $uniq_vals{$v}; | ||
| 1660 | $vals_changed = 1; | ||
| 1661 | } | ||
| 1662 | } | ||
| 1663 | } | ||
| 1664 | |||
| 1665 | if ($vals_changed) { | ||
| 1666 | if (%uniq_vals) { | ||
| 1667 | my $is_num = ( $type eq 'num' || $type eq 'decimal' ) ? 1 : 0; | ||
| 1668 | if ( !$is_num ) { | ||
| 1669 | $is_num = 1; | ||
| 1670 | for my $k ( keys %uniq_vals ) { | ||
| 1671 | if ( $k !~ /^-?[0-9]+(?:\.[0-9]+)?$/ ) { | ||
| 1672 | $is_num = 0; | ||
| 1673 | last; | ||
| 1674 | } | ||
| 1675 | } | ||
| 1676 | } | ||
| 1677 | my @sorted_vals = $is_num ? ( sort { $a <=> $b } keys %uniq_vals ) : ( sort { $a cmp $b } keys %uniq_vals ); | ||
| 1678 | $self->index_put( $index_path, "$pfx$blk:vals", join( "\t", @sorted_vals ), 'raw' ); | ||
| 1679 | } | ||
| 1680 | else { | ||
| 1681 | $self->index_del( $index_path, "$pfx$blk:vals" ); | ||
| 1682 | } | ||
| 1683 | } | ||
| 1684 | } | ||
| 1685 | } | ||
| 1686 | |||
| 1687 | my @del_keys = map { "$pfx$blk:$_" } @del_ids; | ||
| 1688 | $self->index_del( $index_path, \@del_keys ) if @del_keys; | ||
| 1689 | } | ||
| 1690 | } | ||
| 1691 | $self->table_close($index_path); | ||
| 1692 | } | ||
| 1693 | $self->flock_close( $tableid, "records" ); | ||
| 1694 | } | ||
| 1695 | |||
| 1696 | # $adb->normalize_sort_key($value, $type, $len) | ||
| 1697 | # ------------------------------------------------ | ||
| 1698 | sub normalize_sort_key { | ||
| 1699 | my ( $self, $value, $type, $len ) = @_; | ||
| 1700 | |||
| 1701 | $type ||= 'string'; | ||
| 1702 | $len ||= 8; | ||
| 1703 | |||
| 1704 | # Referans Koruması: ARRAY/HASH ref geldiyse skalar değere indirge | ||
| 1705 | if ( ref($value) eq 'ARRAY' ) { | ||
| 1706 | $value = $value->[0]; | ||
| 1707 | } | ||
| 1708 | elsif ( ref($value) eq 'HASH' ) { | ||
| 1709 | $value = ''; # Hash tipleri sıralamaya dahil edilmez | ||
| 1710 | } | ||
| 1711 | elsif ( ref($value) ) { | ||
| 1712 | $value = "$value"; | ||
| 1713 | } | ||
| 1714 | |||
| 1715 | $value //= ''; | ||
| 1716 | |||
| 1717 | # 1. Sayısal Normalizasyon (Sınır: -1e12 ile +9e12 arası, 20 karakter sabit genişlik) | ||
| 1718 | if ( $type eq 'num' || $type eq 'decimal' ) { | ||
| 1719 | my $num = ( $value =~ /^-?[0-9]+(?:\.[0-9]+)?$/ ) ? $value : 0; | ||
| 1720 | return sprintf( "%020.6f", $num + 1_000_000_000_000 ); | ||
| 1721 | } | ||
| 1722 | |||
| 1723 | # 2. Tarih Normalizasyonu | ||
| 1724 | elsif ( $type eq 'date' ) { | ||
| 1725 | my $dateid = $self->str2dateid($value); | ||
| 1726 | return $dateid ? sprintf( "%-14s", $dateid ) : "00000000000000"; | ||
| 1727 | } | ||
| 1728 | |||
| 1729 | # 3. Metin (String) Normalizasyonu (Alfanümerik temizlik) | ||
| 1730 | else { | ||
| 1731 | my $str = lc( $self->to_ascii($value) ); | ||
| 1732 | $str =~ s/[^\w]//g; # Alfanümerik dışındaki karakterler elenir | ||
| 1733 | if ( length($str) > $len ) { | ||
| 1734 | $str = substr( $str, 0, $len ); | ||
| 1735 | } | ||
| 1736 | else { | ||
| 1737 | $str .= " " x ( $len - length($str) ); | ||
| 1738 | } | ||
| 1739 | return $str; | ||
| 1740 | } | ||
| 1741 | } | ||
| 1742 | |||
| 1743 | # $adb->sort_by_block($tableid, \@rids, $sort_opt) | ||
| 1744 | # $norm_opt = $self->normalize_sort_opt($sort_arg); | ||
| 1745 | # Normalizes sorting options: | ||
| 1746 | # sort => { blk => 2 } -> Default: sondan başa (desc: Z->A / 99->0) | ||
| 1747 | # sort => 2 -> Default: sondan başa (desc: Z->A / 99->0) | ||
| 1748 | # sort => { blk => 2, reverse => 1 } -> Tersi: baştan sona (asc: A->Z / 0->99) | ||
| 1749 | # sort => { blk => 2, reverse => 0 } -> Sondan başa (desc) | ||
| 1750 | # sort => { blk => 2, dir => 'asc' } -> Baştan sona (asc) | ||
| 1751 | # sort => { blk => 2, dir => 'desc' } -> Sondan başa (desc) | ||
| 1752 | # ------------------------------------------------ | ||
| 1753 | sub normalize_sort_opt { | ||
| 1754 | my ( $self, $s_opt ) = @_; | ||
| 1755 | return undef unless defined $s_opt && $s_opt ne ''; | ||
| 1756 | |||
| 1757 | my ( $blk, $reverse, $dir ); | ||
| 1758 | |||
| 1759 | if ( ref($s_opt) eq 'HASH' ) { | ||
| 1760 | $blk = $s_opt->{blk} // $s_opt->{block} // $s_opt->{field} // 0; | ||
| 1761 | if ( exists $s_opt->{reverse} ) { | ||
| 1762 | $reverse = $s_opt->{reverse} ? 1 : 0; | ||
| 1763 | $dir = $reverse ? 'asc' : 'desc'; | ||
| 1764 | } | ||
| 1765 | elsif ( exists $s_opt->{dir} ) { | ||
| 1766 | $dir = lc( $s_opt->{dir} ); | ||
| 1767 | $reverse = ( $dir eq 'asc' ) ? 1 : 0; | ||
| 1768 | } | ||
| 1769 | elsif ( exists $s_opt->{order} ) { | ||
| 1770 | $dir = lc( $s_opt->{order} ); | ||
| 1771 | $reverse = ( $dir eq 'asc' ) ? 1 : 0; | ||
| 1772 | } | ||
| 1773 | else { | ||
| 1774 | # Varsayılan: sondan başa (desc) | ||
| 1775 | $reverse = 0; | ||
| 1776 | $dir = 'desc'; | ||
| 1777 | } | ||
| 1778 | } | ||
| 1779 | elsif ( $s_opt =~ /^-(.+)$/ ) { | ||
| 1780 | $blk = $1; | ||
| 1781 | $reverse = 1; | ||
| 1782 | $dir = 'asc'; | ||
| 1783 | } | ||
| 1784 | elsif ( $s_opt =~ /^(.+?)\s+(desc|asc|reverse)$/i ) { | ||
| 1785 | $blk = $1; | ||
| 1786 | $reverse = ( lc($2) eq 'asc' || lc($2) eq 'reverse' ) ? 1 : 0; | ||
| 1787 | $dir = $reverse ? 'asc' : 'desc'; | ||
| 1788 | } | ||
| 1789 | elsif ( $s_opt =~ /^(asc|desc|reverse)$/i ) { | ||
| 1790 | $blk = 0; | ||
| 1791 | $reverse = ( lc($1) eq 'asc' || lc($1) eq 'reverse' ) ? 1 : 0; | ||
| 1792 | $dir = $reverse ? 'asc' : 'desc'; | ||
| 1793 | } | ||
| 1794 | else { | ||
| 1795 | $blk = $s_opt; | ||
| 1796 | $reverse = 0; | ||
| 1797 | $dir = 'desc'; | ||
| 1798 | } | ||
| 1799 | |||
| 1800 | return { | ||
| 1801 | blk => $blk, | ||
| 1802 | reverse => $reverse, | ||
| 1803 | dir => $dir, | ||
| 1804 | ( ( ref($s_opt) eq 'HASH' && $s_opt->{type} ) ? ( type => $s_opt->{type} ) : () ), | ||
| 1805 | }; | ||
| 1806 | } | ||
| 1807 | |||
| 1808 | # $adb->sort_by_block($tableid, \@rids, $sort_opt) | ||
| 1809 | # ------------------------------------------------ | ||
| 1810 | sub sort_by_block { | ||
| 1811 | my ( $self, $tableid, $ids_ref, $s_opt ) = @_; | ||
| 1812 | |||
| 1813 | return () unless ref($ids_ref) eq 'ARRAY' && @$ids_ref; | ||
| 1814 | return $self->db_sortid( $tableid, @$ids_ref ) unless $s_opt; | ||
| 1815 | |||
| 1816 | my $norm = $self->normalize_sort_opt($s_opt); | ||
| 1817 | my $blk = $norm->{blk} // 0; | ||
| 1818 | $blk = $self->resolve_block_idx( $tableid, $blk ) if $tableid; | ||
| 1819 | my $dir = $norm->{dir} // 'desc'; | ||
| 1820 | |||
| 1821 | # If target block is ID (block 0 or 'id'), sort by primary key ID via array_sort | ||
| 1822 | if ( !$blk || $blk eq '0' || $blk eq 'id' ) { | ||
| 1823 | my $id_sort_type = ( $self->config('use_simple') || ( $tableid && $self->table_attr( $tableid, 'use_simple' ) ) ) ? 'ascii' : 'num'; | ||
| 1824 | return $self->array_sort( $id_sort_type, $dir, undef, @$ids_ref ); | ||
| 1825 | } | ||
| 1826 | |||
| 1827 | my $table_info = $tableid ? $self->table_info($tableid) : undef; | ||
| 1828 | my $table_path = $self->table_path($tableid); | ||
| 1829 | my $index_path = "${table_path}.inx"; | ||
| 1830 | |||
| 1831 | my $has_sort_block = 0; | ||
| 1832 | my $type = $norm->{type} // 'auto'; | ||
| 1833 | if ( $table_info && exists $table_info->{sort_block} ) { | ||
| 1834 | foreach my $cfg ( @{ $table_info->{sort_block} } ) { | ||
| 1835 | my $cb = ref($cfg) eq 'HASH' ? ( $cfg->{blk} // $cfg->{block} ) : $cfg; | ||
| 1836 | if ( defined $cb && $cb == $blk ) { | ||
| 1837 | $has_sort_block = 1; | ||
| 1838 | $type = $cfg->{type} if ref($cfg) eq 'HASH' && $cfg->{type}; | ||
| 1839 | last; | ||
| 1840 | } | ||
| 1841 | } | ||
| 1842 | } | ||
| 1843 | |||
| 1844 | my $use_junk = $table_info ? $table_info->{use_junk} : undef; | ||
| 1845 | my $pfx = ( $use_junk && ref($s_opt) eq 'HASH' && $s_opt->{tier} ) ? uc($s_opt->{tier}) . ':' : ''; | ||
| 1846 | my $sort_key_name = "$pfx$blk:keys"; | ||
| 1847 | |||
| 1848 | # Fast path: Pre-sorted binary key buffer from .inx ($blk:keys) | ||
| 1849 | if ( $has_sort_block && -e $index_path ) { | ||
| 1850 | my ( undef, @sorted_master_keys ) = $self->index_get( $index_path, $sort_key_name, "ids", 0, 0, $dir ); | ||
| 1851 | if (@sorted_master_keys) { | ||
| 1852 | my %matched = map { $_ => 1 } @$ids_ref; | ||
| 1853 | my @ordered = grep { delete $matched{$_} } @sorted_master_keys; | ||
| 1854 | push @ordered, keys %matched if %matched; | ||
| 1855 | return @ordered; | ||
| 1856 | } | ||
| 1857 | } | ||
| 1858 | |||
| 1859 | # Fallback when sort index is not built: fetch records and sort via array_sort | ||
| 1860 | if ( ( !defined $type || $type eq 'auto' ) && $table_info && $table_info->{blocks} ) { | ||
| 1861 | if ( ref($table_info->{blocks}) eq 'ARRAY' && ref($table_info->{blocks}[$blk]) eq 'HASH' ) { | ||
| 1862 | my $bt = $table_info->{blocks}[$blk]{type} // ''; | ||
| 1863 | $type = 'num' if $bt =~ /^(num|number|int|float|decimal)$/; | ||
| 1864 | } | ||
| 1865 | } | ||
| 1866 | |||
| 1867 | my @recs = $self->read_list( $tableid, $ids_ref ); | ||
| 1868 | if (@recs) { | ||
| 1869 | @recs = $self->array_sort( $type, $dir, $blk, @recs ); | ||
| 1870 | return map { $_->[0] } @recs; | ||
| 1871 | } | ||
| 1872 | |||
| 1873 | return $self->db_sortid( $tableid, @$ids_ref ); | ||
| 1874 | } | ||
| 1875 | |||
| 1876 | # $adb->sort_by_block_records($tableid, \@records, $sort_opt) | ||
| 1877 | # ------------------------------------------------ | ||
| 1878 | sub sort_by_block_records { | ||
| 1879 | my ( $self, $tableid, $recs_ref, $s_opt ) = @_; | ||
| 1880 | |||
| 1881 | return () unless ref($recs_ref) eq 'ARRAY' && @$recs_ref; | ||
| 1882 | return $self->db_sortid( $tableid, @$recs_ref ) unless $s_opt; | ||
| 1883 | |||
| 1884 | my $norm = $self->normalize_sort_opt($s_opt); | ||
| 1885 | my $blk = $norm->{blk} // 0; | ||
| 1886 | $blk = $self->resolve_block_idx( $tableid, $blk ) if $tableid; | ||
| 1887 | my $dir = $norm->{dir} // 'desc'; | ||
| 1888 | |||
| 1889 | my $table_info = $tableid ? $self->table_info($tableid) : undef; | ||
| 1890 | my $type = $norm->{type} // 'auto'; | ||
| 1891 | if ( ( !defined $type || $type eq 'auto' ) && $table_info && exists $table_info->{sort_block} ) { | ||
| 1892 | foreach my $cfg ( @{ $table_info->{sort_block} } ) { | ||
| 1893 | my $cb = ref($cfg) eq 'HASH' ? ( $cfg->{blk} // $cfg->{block} ) : $cfg; | ||
| 1894 | if ( defined $cb && $cb == $blk ) { | ||
| 1895 | $type = $cfg->{type} if ref($cfg) eq 'HASH' && $cfg->{type}; | ||
| 1896 | last; | ||
| 1897 | } | ||
| 1898 | } | ||
| 1899 | } | ||
| 1900 | if ( ( !defined $type || $type eq 'auto' ) && $table_info && $table_info->{blocks} ) { | ||
| 1901 | if ( ref($table_info->{blocks}) eq 'ARRAY' && ref($table_info->{blocks}[$blk]) eq 'HASH' ) { | ||
| 1902 | my $bt = $table_info->{blocks}[$blk]{type} // ''; | ||
| 1903 | $type = 'num' if $bt =~ /^(num|number|int|float|decimal)$/; | ||
| 1904 | } | ||
| 1905 | } | ||
| 1906 | $type //= ( $blk == 0 ) ? ( ( $self->config('use_simple') || ( $table_info && $table_info->{use_simple} ) ) ? 'ascii' : 'num' ) : 'auto'; | ||
| 1907 | |||
| 1908 | return $self->array_sort( $type, $dir, $blk, @$recs_ref ); | ||
| 1909 | } | ||
| 1910 | |||
| 1911 | # ------------------------------------------------ | ||
| 1912 | # Autocomplete / Suggest Index Lifecycle Methods (.ajw, .ajn) | ||
| 1913 | # ------------------------------------------------ | ||
| 1914 | |||
| 1915 | sub _extract_suggest_sentences { | ||
| 1916 | my ( $self, $table_info, $rec, $rdbm_recs, $rdbm_blocks ) = @_; | ||
| 1917 | |||
| 1918 | return () unless ref($table_info) eq 'HASH' && ref($rec) eq 'ARRAY'; | ||
| 1919 | my $suggest_blocks = $table_info->{suggest_block}; | ||
| 1920 | return () unless ref($suggest_blocks) eq 'ARRAY' && @$suggest_blocks; | ||
| 1921 | |||
| 1922 | my %join_left_blocks; | ||
| 1923 | if ( ref( $table_info->{suggest_join} ) eq 'ARRAY' ) { | ||
| 1924 | for my $rule ( @{ $table_info->{suggest_join} } ) { | ||
| 1925 | if ( ref($rule) eq 'ARRAY' && @$rule ) { | ||
| 1926 | $join_left_blocks{ $rule->[0] } = 1; | ||
| 1927 | } | ||
| 1928 | } | ||
| 1929 | } | ||
| 1930 | |||
| 1931 | my %block_vals; | ||
| 1932 | for my $blk ( @$suggest_blocks ) { | ||
| 1933 | my $real_blk = ref($blk) eq 'ARRAY' ? $blk->[0] : $blk; | ||
| 1934 | my $val = $rec->[$real_blk]; | ||
| 1935 | next unless defined $val && $val ne ''; | ||
| 1936 | |||
| 1937 | my $rdbm = $rdbm_blocks ? $rdbm_blocks->{$real_blk} : undef; | ||
| 1938 | if ( $rdbm ) { | ||
| 1939 | my $target_table = $rdbm->{table}; | ||
| 1940 | my $disp = $rdbm->{display} // 1; | ||
| 1941 | my @parts; | ||
| 1942 | for my $sid ( split /[,;]/, $val ) { | ||
| 1943 | $sid =~ s/^\s+|\s+$//g; | ||
| 1944 | next unless length $sid; | ||
| 1945 | if ( my $target_rec = $rdbm_recs->{$target_table}->{$sid} ) { | ||
| 1946 | my $name = $target_rec->[$disp]; | ||
| 1947 | if ( defined $name && length $name ) { | ||
| 1948 | $name =~ s/^\s+|\s+$//g; | ||
| 1949 | push @parts, $name if length $name; | ||
| 1950 | } | ||
| 1951 | } | ||
| 1952 | } | ||
| 1953 | $block_vals{$real_blk} = \@parts if @parts; | ||
| 1954 | } | ||
| 1955 | else { | ||
| 1956 | $val =~ s/^\s+|\s+$//g; | ||
| 1957 | if ( length $val ) { | ||
| 1958 | if ( $val =~ /^\d+(\s*[,;]\s*\d+)+$/ || ( $join_left_blocks{$real_blk} && $val =~ /[,;]/ ) ) { | ||
| 1959 | my @parts = grep { length } split /\s*[,;]\s*/, $val; | ||
| 1960 | $block_vals{$real_blk} = \@parts if @parts; | ||
| 1961 | } | ||
| 1962 | else { | ||
| 1963 | $block_vals{$real_blk} = [ $val ]; | ||
| 1964 | } | ||
| 1965 | } | ||
| 1966 | } | ||
| 1967 | } | ||
| 1968 | |||
| 1969 | my @sentences; | ||
| 1970 | # 1. Standalone sentences | ||
| 1971 | for my $blk ( @$suggest_blocks ) { | ||
| 1972 | my $real_blk = ref($blk) eq 'ARRAY' ? $blk->[0] : $blk; | ||
| 1973 | if ( my $parts = $block_vals{$real_blk} ) { | ||
| 1974 | push @sentences, @$parts; | ||
| 1975 | if ( @$parts > 1 ) { | ||
| 1976 | push @sentences, join( ' ', @$parts ); | ||
| 1977 | } | ||
| 1978 | } | ||
| 1979 | } | ||
| 1980 | |||
| 1981 | # 2. Joined sentences based on suggest_join | ||
| 1982 | if ( ref( $table_info->{suggest_join} ) eq 'ARRAY' ) { | ||
| 1983 | for my $rule ( @{ $table_info->{suggest_join} } ) { | ||
| 1984 | next unless ref($rule) eq 'ARRAY' && @$rule >= 2; | ||
| 1985 | my ( $b1, $b2 ) = ( $rule->[0], $rule->[1] ); | ||
| 1986 | my $p1 = $block_vals{$b1}; | ||
| 1987 | my $p2 = $block_vals{$b2}; | ||
| 1988 | next unless $p1 && @$p1 && $p2 && @$p2; | ||
| 1989 | |||
| 1990 | for my $s1 (@$p1) { | ||
| 1991 | for my $s2 (@$p2) { | ||
| 1992 | push @sentences, "$s1 $s2"; | ||
| 1993 | } | ||
| 1994 | } | ||
| 1995 | if ( @$p1 > 1 ) { | ||
| 1996 | my $all_p1 = join( ' ', @$p1 ); | ||
| 1997 | for my $s2 (@$p2) { | ||
| 1998 | push @sentences, "$all_p1 $s2"; | ||
| 1999 | } | ||
| 2000 | } | ||
| 2001 | } | ||
| 2002 | } | ||
| 2003 | |||
| 2004 | my %seen; | ||
| 2005 | @sentences = grep { defined $_ && length($_) >= 2 && !$seen{$_}++ } @sentences; | ||
| 2006 | return @sentences; | ||
| 2007 | } | ||
| 2008 | |||
| 2009 | sub _extract_words_and_transitions { | ||
| 2010 | my ( $self, @sentences ) = @_; | ||
| 2011 | |||
| 2012 | my ( %word_freq, %transitions ); | ||
| 2013 | |||
| 2014 | for my $sent (@sentences) { | ||
| 2015 | # 1. Strip punctuation (commas, dots, colons, brackets, quotes, etc.) | ||
| 2016 | $sent =~ s/[.,:;()\[\]{}"“”?!\\\/&_+*~^%#@=<>|]/ /g; | ||
| 2017 | # 2. Clean isolated/dangling hyphens and quotes (e.g. " - ", " ' ") | ||
| 2018 | $sent =~ s/(?:^|\s)[-\'\x{2019}\x{2018}\x{2032}\x{02BC}]+(?=\s|$)/ /g; | ||
| 2019 | |||
| 2020 | my @raw_words = split /\s+/, $sent; | ||
| 2021 | my @word_tokens; | ||
| 2022 | |||
| 2023 | for my $rw (@raw_words) { | ||
| 2024 | $rw =~ s/^[^\w\x80-\xff]+|[^\w\x80-\xff]+$//g; | ||
| 2025 | next unless length($rw) >= 2; | ||
| 2026 | |||
| 2027 | # Yazma modu (is_write = 1), no_ascii = 1 (preserve alphabet_chars) | ||
| 2028 | my $norm_str = $self->normalize_word( $rw, 1, 1 ); | ||
| 2029 | my @toks = grep { length($_) >= 2 } split /\s+/, $norm_str; | ||
| 2030 | next unless @toks; | ||
| 2031 | |||
| 2032 | for my $tok (@toks) { | ||
| 2033 | $word_freq{$tok}{disp} //= $tok; | ||
| 2034 | $word_freq{$tok}{cnt}++; | ||
| 2035 | } | ||
| 2036 | push @word_tokens, \@toks; | ||
| 2037 | } | ||
| 2038 | |||
| 2039 | for ( my $i = 0; $i < $#word_tokens; $i++ ) { | ||
| 2040 | for my $n1 ( @{ $word_tokens[$i] } ) { | ||
| 2041 | my $a1 = $self->to_ascii($n1); | ||
| 2042 | for my $n2 ( @{ $word_tokens[$i + 1] } ) { | ||
| 2043 | my $a2 = $self->to_ascii($n2); | ||
| 2044 | $transitions{$n1}{$n2}{disp} //= $n2; | ||
| 2045 | $transitions{$n1}{$n2}{cnt}++; | ||
| 2046 | if ( defined $a1 && $a1 ne $n1 ) { | ||
| 2047 | $transitions{$a1}{$n2}{disp} //= $n2; | ||
| 2048 | $transitions{$a1}{$n2}{cnt}++; | ||
| 2049 | } | ||
| 2050 | } | ||
| 2051 | } | ||
| 2052 | } | ||
| 2053 | } | ||
| 2054 | |||
| 2055 | return ( \%word_freq, \%transitions ); | ||
| 2056 | } | ||
| 2057 | |||
| 2058 | sub suggest_add { | ||
| 2059 | my ( $self, $table_path, $table_info, $tableid, $records, $tier ) = @_; | ||
| 2060 | |||
| 2061 | return unless exists $table_info->{suggest_block}; | ||
| 2062 | return unless ref($records) eq 'ARRAY' && @$records; | ||
| 2063 | |||
| 2064 | # 1. Identify RDBM blocks and prepare pre-fetch | ||
| 2065 | my %rdbm_blocks; | ||
| 2066 | for my $blk ( @{ $table_info->{suggest_block} } ) { | ||
| 2067 | my ( $real_blk, $src_table, $src_display ) = | ||
| 2068 | ref($blk) eq 'ARRAY' ? ( $blk->[0], $blk->[1], $blk->[2] ) | ||
| 2069 | : ( $blk, undef, undef ); | ||
| 2070 | |||
| 2071 | if ( !$src_table ) { | ||
| 2072 | ( $src_table, $src_display ) = $self->rdbm_target( $table_info, $real_blk ); | ||
| 2073 | } | ||
| 2074 | if ( $src_table ) { | ||
| 2075 | $src_display //= 1; | ||
| 2076 | $rdbm_blocks{$real_blk} = { table => $src_table, display => $src_display }; | ||
| 2077 | } | ||
| 2078 | } | ||
| 2079 | |||
| 2080 | # 2. Collect unique foreign IDs across records | ||
| 2081 | my ( %foreign_ids, %rdbm_recs ); | ||
| 2082 | if ( %rdbm_blocks ) { | ||
| 2083 | for my $rec (@$records) { | ||
| 2084 | for my $real_blk ( keys %rdbm_blocks ) { | ||
| 2085 | my $val = $rec->[$real_blk]; | ||
| 2086 | next unless defined $val && $val ne ''; | ||
| 2087 | my $target_table = $rdbm_blocks{$real_blk}->{table}; | ||
| 2088 | for my $id ( split /[,;]/, $val ) { | ||
| 2089 | $id =~ s/^\s+|\s+$//g; | ||
| 2090 | $foreign_ids{$target_table}->{$id} = 1 if $id =~ /^\d+$/; | ||
| 2091 | } | ||
| 2092 | } | ||
| 2093 | } | ||
| 2094 | for my $target_table ( keys %foreign_ids ) { | ||
| 2095 | my @ids = keys %{ $foreign_ids{$target_table} }; | ||
| 2096 | next unless @ids; | ||
| 2097 | my @target_records = $self->read_list( $target_table, \@ids ); | ||
| 2098 | $rdbm_recs{$target_table} = { map { $_->[0] => $_ } @target_records }; | ||
| 2099 | } | ||
| 2100 | } | ||
| 2101 | |||
| 2102 | # 3. Extract sentences across all records in batch | ||
| 2103 | my @all_sentences; | ||
| 2104 | for my $rec (@$records) { | ||
| 2105 | push @all_sentences, $self->_extract_suggest_sentences( $table_info, $rec, \%rdbm_recs, \%rdbm_blocks ); | ||
| 2106 | } | ||
| 2107 | return unless @all_sentences; | ||
| 2108 | |||
| 2109 | my ( $word_freq, $transitions ) = $self->_extract_words_and_transitions( @all_sentences ); | ||
| 2110 | return unless %$word_freq; | ||
| 2111 | |||
| 2112 | my $ajw_path = "${table_path}.ajw"; | ||
| 2113 | my $ajn_path = "${table_path}.ajn"; | ||
| 2114 | |||
| 2115 | # Open .ajw and .ajn for writing | ||
| 2116 | my $ajw_opened = 0; | ||
| 2117 | if ( !$self->{_db}->{$ajw_path} ) { | ||
| 2118 | $self->table_write($ajw_path) or do { | ||
| 2119 | $self->transact_error( $ajw_path, "cannot open .ajw" ); | ||
| 2120 | return; | ||
| 2121 | }; | ||
| 2122 | $ajw_opened = 1; | ||
| 2123 | } | ||
| 2124 | my $ajn_opened = 0; | ||
| 2125 | if ( !$self->{_db}->{$ajn_path} ) { | ||
| 2126 | $self->table_write($ajn_path) or do { | ||
| 2127 | $self->table_close($ajw_path) if $ajw_opened; | ||
| 2128 | $self->transact_error( $ajn_path, "cannot open .ajn" ); | ||
| 2129 | return; | ||
| 2130 | }; | ||
| 2131 | $ajn_opened = 1; | ||
| 2132 | } | ||
| 2133 | |||
| 2134 | # 4. Update .ajw (Word prefix index, max 10 per prefix) | ||
| 2135 | my %prefixes_to_update; | ||
| 2136 | for my $norm ( keys %$word_freq ) { | ||
| 2137 | my $disp = $word_freq->{$norm}{disp}; | ||
| 2138 | my $cnt = $word_freq->{$norm}{cnt}; | ||
| 2139 | my $max_len = length($norm) < 12 ? length($norm) : 12; | ||
| 2140 | for ( my $len = 2; $len <= $max_len; $len++ ) { | ||
| 2141 | my $pfx = substr($norm, 0, $len); | ||
| 2142 | $prefixes_to_update{$pfx}{$norm} = [ $disp, $cnt ]; | ||
| 2143 | } | ||
| 2144 | my $ascii_norm = $self->to_ascii($norm); | ||
| 2145 | if ( defined $ascii_norm && $ascii_norm ne $norm ) { | ||
| 2146 | my $a_len = length($ascii_norm) < 12 ? length($ascii_norm) : 12; | ||
| 2147 | for ( my $len = 2; $len <= $a_len; $len++ ) { | ||
| 2148 | my $a_pfx = substr($ascii_norm, 0, $len); | ||
| 2149 | $prefixes_to_update{$a_pfx}{$norm} = [ $disp, $cnt ]; | ||
| 2150 | } | ||
| 2151 | } | ||
| 2152 | } | ||
| 2153 | |||
| 2154 | my @pfx_keys = keys %prefixes_to_update; | ||
| 2155 | my $existing_ajw = @pfx_keys ? $self->recs_get( $ajw_path, @pfx_keys ) : {}; | ||
| 2156 | my @ajw_to_put; | ||
| 2157 | |||
| 2158 | for my $pfx (@pfx_keys) { | ||
| 2159 | my %merged; | ||
| 2160 | if ( my $raw = $existing_ajw->{$pfx} ) { | ||
| 2161 | my $old_items = $self->db_decode($raw); | ||
| 2162 | if ( ref($old_items) eq 'ARRAY' ) { | ||
| 2163 | for my $it (@$old_items) { | ||
| 2164 | next unless ref($it) eq 'ARRAY'; | ||
| 2165 | my $n = $self->to_ascii( $self->lc($it->[0]) ); | ||
| 2166 | $merged{$n} = [ $it->[0], $it->[1] ]; | ||
| 2167 | } | ||
| 2168 | } | ||
| 2169 | } | ||
| 2170 | for my $n ( keys %{ $prefixes_to_update{$pfx} } ) { | ||
| 2171 | my $new_it = $prefixes_to_update{$pfx}{$n}; | ||
| 2172 | if ( exists $merged{$n} ) { | ||
| 2173 | $merged{$n}->[1] += $new_it->[1]; | ||
| 2174 | } | ||
| 2175 | else { | ||
| 2176 | $merged{$n} = [ $new_it->[0], $new_it->[1] ]; | ||
| 2177 | } | ||
| 2178 | } | ||
| 2179 | my @sorted = sort { | ||
| 2180 | $merged{$b}->[1] <=> $merged{$a}->[1] | ||
| 2181 | || $a cmp $b | ||
| 2182 | } keys %merged; | ||
| 2183 | @sorted = @sorted[0 .. 9] if @sorted > 10; | ||
| 2184 | my @payload = map { $merged{$_} } @sorted; | ||
| 2185 | push @ajw_to_put, [ $pfx, $self->db_encode(\@payload) ]; | ||
| 2186 | } | ||
| 2187 | $self->recs_put( [ $ajw_path, $tableid ], @ajw_to_put ) if @ajw_to_put; | ||
| 2188 | |||
| 2189 | # 5. Update .ajn (Next word transitions, unlimited / up to 300) | ||
| 2190 | my @norm1_keys = keys %$transitions; | ||
| 2191 | my $existing_ajn = @norm1_keys ? $self->recs_get( $ajn_path, @norm1_keys ) : {}; | ||
| 2192 | my @ajn_to_put; | ||
| 2193 | |||
| 2194 | for my $norm1 (@norm1_keys) { | ||
| 2195 | my %merged; | ||
| 2196 | if ( my $raw = $existing_ajn->{$norm1} ) { | ||
| 2197 | my $old_items = $self->db_decode($raw); | ||
| 2198 | if ( ref($old_items) eq 'ARRAY' ) { | ||
| 2199 | for my $it (@$old_items) { | ||
| 2200 | next unless ref($it) eq 'ARRAY'; | ||
| 2201 | my $n2 = $it->[2] // $self->to_ascii( $self->lc($it->[0]) ); | ||
| 2202 | $merged{$n2} = { disp => $it->[0], cnt => $it->[1] }; | ||
| 2203 | } | ||
| 2204 | } | ||
| 2205 | } | ||
| 2206 | my $new_t = $transitions->{$norm1}; | ||
| 2207 | for my $n2 ( keys %$new_t ) { | ||
| 2208 | if ( exists $merged{$n2} ) { | ||
| 2209 | $merged{$n2}{cnt} += $new_t->{$n2}{cnt}; | ||
| 2210 | } | ||
| 2211 | else { | ||
| 2212 | $merged{$n2} = { disp => $new_t->{$n2}{disp}, cnt => $new_t->{$n2}{cnt} }; | ||
| 2213 | } | ||
| 2214 | } | ||
| 2215 | my @sorted = sort { | ||
| 2216 | $merged{$b}{cnt} <=> $merged{$a}{cnt} | ||
| 2217 | || $a cmp $b | ||
| 2218 | } keys %merged; | ||
| 2219 | @sorted = @sorted[0 .. 299] if @sorted > 300; | ||
| 2220 | my @payload = map { | ||
| 2221 | [ $merged{$_}{disp}, $merged{$_}{cnt}, $_ ] | ||
| 2222 | } @sorted; | ||
| 2223 | push @ajn_to_put, [ $norm1, $self->db_encode(\@payload) ]; | ||
| 2224 | } | ||
| 2225 | $self->recs_put( [ $ajn_path, $tableid ], @ajn_to_put ) if @ajn_to_put; | ||
| 2226 | |||
| 2227 | if ($ajw_opened) { | ||
| 2228 | $self->table_close($ajw_path); | ||
| 2229 | } | ||
| 2230 | if ($ajn_opened) { | ||
| 2231 | $self->table_close($ajn_path); | ||
| 2232 | } | ||
| 2233 | |||
| 2234 | return 1; | ||
| 2235 | } | ||
| 2236 | |||
| 2237 | 1; | ||
| 2238 | |||
| 2239 | |||
| 2240 | |||
| 2241 | __END__ |