blib/lib/AmberDB/Base/Index.pm untested

filter: Statementstmt 0.0% 0 / 1498 Branchbran 0.0% 0 / 934 Conditioncond 0.0% 0 / 920 MC/DCmcdc 0.0% 0 / 554 Subroutinesub 0.0% 0 / 38 Podpod 0.0% 0 / 35 totaltotal 0.0% 0 / 3979 CC 468 SCAR 60.4
CC
468
Cov
0%
suggest_add
1190.0
sort_del
930.0
search_modify
756.0
CRAP 419.9
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__