3 |
# $Id$ |
# $Id$ |
4 |
# |
# |
5 |
# $Log$ |
# $Log$ |
6 |
|
# Revision 1.43 2003/07/02 11:07:12 jonen |
7 |
|
# re-activate filtering of results *after* results are fetched from tangram |
8 |
|
# (needed for e.g. UserManagment) |
9 |
|
# |
10 |
|
# Revision 1.42 2003/07/01 23:24:17 joko |
11 |
|
# now using package before using function |
12 |
|
# |
13 |
|
# Revision 1.41 2003/06/29 02:03:45 joko |
14 |
|
# fix:? initialize schema on startup |
15 |
|
# |
16 |
|
# Revision 1.40 2003/06/25 22:57:54 joko |
17 |
|
# major rework of "sub sendQuery / sub getListFiltered": now should be capable of "sorting" |
18 |
|
# |
19 |
|
# Revision 1.39 2003/06/06 11:40:40 jonen |
20 |
|
# fixed bug at 'getFilteredList' |
21 |
|
# |
22 |
|
# Revision 1.38 2003/05/13 16:38:38 joko |
23 |
|
# problems with "tied" on 5.6.1/win32 |
24 |
|
# |
25 |
|
# Revision 1.37 2003/05/10 17:37:39 jonen |
26 |
|
# corrected last commit |
27 |
|
# |
28 |
|
# Revision 1.36 2003/05/10 17:31:18 jonen |
29 |
|
# + added new functions related to 'create' item |
30 |
|
# - createNode() |
31 |
|
# # creates non-persistent 'deep dummy filled' object |
32 |
|
# - insertChildNode() |
33 |
|
# # inserts child node at given parent (child node haven't to exists, |
34 |
|
# createNode will be injected transparently) |
35 |
|
# |
36 |
# Revision 1.35 2003/04/19 16:09:48 jonen |
# Revision 1.35 2003/04/19 16:09:48 jonen |
37 |
# + added operator dispatching (currently for getting ref-type) at 'getListFiltered' |
# + added operator dispatching (currently for getting ref-type) at 'getListFiltered' |
38 |
# |
# |
173 |
|
|
174 |
use Data::Dumper; |
use Data::Dumper; |
175 |
use Tangram; |
use Tangram; |
176 |
|
use Class::Tangram; |
177 |
|
|
178 |
use DesignPattern::Object; |
use DesignPattern::Object; |
179 |
use Data::Storage::Result::Tangram; |
use Data::Storage::Result::Tangram; |
201 |
#if (!$schema_tangram) { |
#if (!$schema_tangram) { |
202 |
#my $obj = getNewPerlObjectByPkgName($self->{locator}->{schema}, { EXPORT_OBJECTS => $self->{locator}->{classnames}, want_transactions => $self->{locator}->{want_transactions} } ); |
#my $obj = getNewPerlObjectByPkgName($self->{locator}->{schema}, { EXPORT_OBJECTS => $self->{locator}->{classnames}, want_transactions => $self->{locator}->{want_transactions} } ); |
203 |
my $obj = DesignPattern::Object->fromPackage($self->{locator}->{schema}, { 'EXPORT_OBJECTS' => $self->{locator}->{classnames}, 'want_transactions' => $self->{locator}->{want_transactions} } ); |
my $obj = DesignPattern::Object->fromPackage($self->{locator}->{schema}, { 'EXPORT_OBJECTS' => $self->{locator}->{classnames}, 'want_transactions' => $self->{locator}->{want_transactions} } ); |
204 |
$schema_tangram = $obj->getSchema(); |
$schema_tangram = $obj->getSchema() if $obj; |
205 |
#} |
#} |
206 |
if (!$schema_tangram) { |
if (!$schema_tangram) { |
207 |
$logger->error( __PACKAGE__ . "->_initSchema: No Schema available for $self->{schema}" ); |
$logger->error( __PACKAGE__ . "->_initSchema: No Schema available for $self->{locator}->{schema}." ); |
208 |
return 0; |
return 0; |
209 |
} |
} |
210 |
#$self->_patchSchema(); |
#$self->_patchSchema(); |
250 |
# return; |
# return; |
251 |
# } |
# } |
252 |
|
|
253 |
#return unless $self->_initSchema(); |
return unless $self->_initSchema(); |
254 |
$self->_initSchema(); |
#$self->_initSchema(); |
255 |
|
|
256 |
# create the main tangram storage object |
# create the main tangram storage object |
257 |
#$self->{COREHANDLE} = Tangram::Relational->connect( $schema, $dsn ); |
#$self->{COREHANDLE} = Tangram::Relational->connect( $schema, $dsn ); |
513 |
# redirect to unfiltered mode |
# redirect to unfiltered mode |
514 |
#return $self->getListUnfiltered(@_); |
#return $self->getListUnfiltered(@_); |
515 |
|
|
516 |
my $nodename = shift; |
my $in = {}; |
517 |
my $filters = shift; |
$in->{nodename} = shift; |
518 |
|
$in->{filters} = shift; |
519 |
|
$in->{sorting} = shift; |
520 |
|
|
521 |
my @results; |
my @results; |
522 |
$logger->debug( __PACKAGE__ . "->getListFiltered( nodename => '" . $nodename . "' )" ); |
$logger->debug( __PACKAGE__ . "->getListFiltered( nodename => '" . $in->{nodename} . "' )" ); |
523 |
|
|
524 |
|
#print Dumper($filters); |
525 |
|
|
526 |
#print Dumper($filters); |
# 1. "Remote Object Handle" - get set of objects from odbms by object name |
527 |
|
my $remote = $self->{_COREHANDLE}->remote($in->{nodename}); |
528 |
|
|
529 |
|
# 2. Transfer $in to $orm_query |
530 |
|
my $orm_query = {}; |
531 |
|
|
532 |
|
# 2.a. Filters |
533 |
my @tfilters; |
my @tfilters; |
534 |
|
my $orm_filter = undef; |
535 |
|
|
536 |
foreach my $filter (@$filters) { |
foreach my $filter (@{$in->{filters}}) { |
537 |
|
|
538 |
# get filter - TODO: for each filter |
# get filter - TODO: for each filter |
539 |
#my $filter = $filters->[0]; |
#my $filter = $filters->[0]; |
540 |
|
|
541 |
# build filter |
# 1. The parts of a filter source entry |
542 |
my $lexpr = $filter->{key}; |
my $lexpr = $filter->{key}; |
543 |
#my $op = $filter->{op}; |
#my $op = $filter->{op}; |
544 |
my $op = '='; |
my $op = '='; |
545 |
my $rexpr = $filter->{val}; |
my $rexpr = $filter->{val}; |
546 |
my $tight = 100; |
my $tight = 100; |
547 |
|
|
548 |
|
# 2. Build filter target entry |
549 |
|
|
550 |
# my $tfilter = Tangram::Filter->new( |
# Test 1 - didn't work out! |
551 |
# expr => "t1.$lexpr $op '$rexpr'", |
# my $tfilter = Tangram::Filter->new( |
552 |
# tight => $tight, |
# expr => "t1.$lexpr $op '$rexpr'", |
553 |
# objects => $objects, |
# tight => $tight, |
554 |
# ); |
# objects => $objects, |
555 |
|
# ); |
556 |
|
|
557 |
|
my $orm_filter_tmp = undef; |
558 |
|
# was: |
559 |
# TODO: is_op? |
# TODO: is_op? |
560 |
# dispatch un-common operators if exists |
# dispatch un-common operators if exists |
561 |
if($filter->{op} eq "ref") { |
if ($filter->{op} eq "ref") { |
562 |
push @tfilters, 'ref($remote->{' . $filter->{key} . '})' . " eq '$filter->{val}'"; |
# do nothing, results will be filtered later cause 'tangram-filter' doesn't support 'ref' query |
563 |
|
#print "Filter->op eq 'ref'.\n"; |
564 |
|
#push @tfilters, 'ref($remote->{' . $filter->{key} . '})' . " eq '$filter->{val}'"; |
565 |
} else { |
} else { |
566 |
# HACK: build eval-string (sorry) to get filtered list - please give advice here |
# HACK: build eval-string (sorry) to get filtered list - please give advice here |
567 |
push @tfilters, '$remote->{' . $filter->{key} . '}' . " $filter->{op} '$filter->{val}'"; |
#push @tfilters, '$remote->{' . $filter->{key} . '}' . " $filter->{op} '$filter->{val}'"; |
568 |
|
# better: calculate expression right here! |
569 |
|
#push @tfilters, '$remote->{' . $filter->{key} . '}' . " $filter->{op} '$filter->{val}'"; |
570 |
|
|
571 |
|
#print "key: ", $filter->{key}, "\n"; |
572 |
|
|
573 |
|
my $left = $remote->{$filter->{key}}; |
574 |
|
#my $r = Tangram::Expr->new( 'string' => "'" . $filter->{val} . "'" ); |
575 |
|
my $right = $filter->{val}; |
576 |
|
my $op = $filter->{op}; |
577 |
|
$orm_filter_tmp = $left->$op($right); |
578 |
|
} |
579 |
|
|
580 |
|
if (not $orm_filter) { |
581 |
|
$orm_filter = $orm_filter_tmp; |
582 |
|
} else { |
583 |
|
$orm_filter = $orm_filter->and($orm_filter_tmp); |
584 |
} |
} |
585 |
|
|
586 |
} |
} |
587 |
|
|
588 |
my $tfilter = join(' & ', @tfilters); |
$orm_query->{filter} = $orm_filter; |
589 |
|
|
|
# get set of objects from odbms by object name |
|
|
my $remote = $self->{_COREHANDLE}->remote($nodename); |
|
|
|
|
590 |
# was: |
# was: |
591 |
#@results = $self->{COREHANDLE}->select($object_set, $tfilter); |
|
592 |
|
# 2.b. sorting [new as of 2003-06-17] |
593 |
|
if ($in->{sorting}) { |
594 |
|
my $sorting_rules = []; |
595 |
|
my $sorting_order = 'ASC'; |
596 |
|
foreach my $sorting_column (keys %{$in->{sorting}}) { |
597 |
|
$sorting_order = $in->{sorting}->{$sorting_column} if $in->{sorting}->{$sorting_column}; |
598 |
|
push @$sorting_rules, Tangram::Expr->new( 'string' => $sorting_column ); |
599 |
|
} |
600 |
|
$orm_query->{order} = $sorting_rules; |
601 |
|
if ($sorting_order eq 'DESC') { |
602 |
|
$orm_query->{desc} = 1; |
603 |
|
} |
604 |
|
} |
605 |
|
|
606 |
|
|
607 |
|
# 3. build and issue query - return result as Tangram::Cursor |
608 |
|
|
609 |
|
# coerce hash into array (This is valid in Perl) |
610 |
|
my @orm_query_args = %$orm_query; |
611 |
|
# send query (arguments) to orm |
612 |
|
@results = $self->{_COREHANDLE}->select($remote, @orm_query_args); |
613 |
|
|
614 |
|
#my $cursor = $self->{_COREHANDLE}->cursor($remote, @orm_query_args); |
615 |
|
#return $cursor; |
616 |
|
#print Dumper(@results); |
617 |
|
|
618 |
# is: |
# is: |
619 |
# HACK: build eval-string (sorry) to get filtered list - please give advice here |
# HACK: build eval-string (sorry) to get filtered list - please give advice here |
620 |
my $evalstring = 'return $self->{_COREHANDLE}->select($remote, ' . $tfilter . ');'; |
#my $evalstring = 'return $self->{_COREHANDLE}->select($remote, ' . $tfilter . $sorting . ');'; |
621 |
|
#print "eval: $evalstring", "\n"; |
622 |
#print "eval: $evalstring", "\n"; |
# get filtered list/set |
623 |
|
#@results = eval($evalstring); |
624 |
# get filtered list/set |
#die $@ if $@; |
625 |
@results = eval($evalstring); |
|
626 |
die $@ if $@; |
# filter results - NEEDED for e.g. UserManagment !! |
627 |
|
if ($in->{filters}->[0]->{op} && ($in->{filters}->[0]->{op} eq "ref")) { |
628 |
|
#print "Filter->op eq 'ref'.\n"; |
629 |
|
my $att_name = $in->{filters}->[0]->{key}; |
630 |
|
my $att_val = $in->{filters}->[0]->{val}; |
631 |
|
my @filtered; |
632 |
|
foreach(@results) { |
633 |
|
if(ref($_->{$att_name}) eq $att_val) { |
634 |
|
push @filtered, $_; |
635 |
|
} |
636 |
|
} |
637 |
|
@results = @filtered; |
638 |
|
} |
639 |
|
|
640 |
|
#print "results: " . Dumper(\@results); |
641 |
|
|
642 |
return \@results; |
return \@results; |
643 |
} |
} |
667 |
return $result; |
return $result; |
668 |
} |
} |
669 |
|
|
670 |
|
sub createResult { |
671 |
|
my $self = shift; |
672 |
|
my $rh = shift; |
673 |
|
my $result = Data::Storage::Result::Tangram->new( RESULTHANDLE => $rh ); |
674 |
|
return $result; |
675 |
|
} |
676 |
|
|
677 |
sub sendQuery { |
sub sendQuery { |
678 |
my $self = shift; |
my $self = shift; |
679 |
my $query = shift; |
my $query = shift; |
765 |
|
|
766 |
if ($crud eq 'RETRIEVE') { |
if ($crud eq 'RETRIEVE') { |
767 |
|
|
768 |
my $list = $self->getListFiltered($query->{node}, $query->{criterias}); |
my $list = $self->getListFiltered($query->{node}, $query->{criterias}, $query->{sorting}); |
769 |
|
#return $list; |
770 |
|
return $self->createResult($list); |
771 |
|
|
772 |
#return $self->createSet($object); |
#return $self->createSet($object); |
773 |
#return $self->createSet($list); |
#return $self->createSet($list); |
774 |
return $self->createSet(@$list); |
return $self->createSet(@$list); |
825 |
|
|
826 |
$self->erase($object); |
$self->erase($object); |
827 |
|
|
828 |
|
} elsif ($crud eq 'CREATE') { |
829 |
|
|
830 |
|
my $nodename = $query->{node}; |
831 |
|
my $newnode = $self->createNode($nodename); |
832 |
|
my $id = $self->{_COREHANDLE}->insert($newnode); |
833 |
|
|
834 |
|
print "Saved new node $nodename with GUID $newnode->{guid}, OID '$id': " . Dumper($newnode) . "\n"; |
835 |
|
|
836 |
|
return $newnode; |
837 |
|
|
838 |
} |
} |
839 |
|
|
840 |
} |
} |
989 |
$self->{dataStorageLayer}->disconnect(); |
$self->{dataStorageLayer}->disconnect(); |
990 |
} |
} |
991 |
|
|
992 |
|
|
993 |
|
sub createNode { |
994 |
|
my $self = shift; |
995 |
|
my $classname = shift; |
996 |
|
|
997 |
|
my $obj = $classname->new(); |
998 |
|
|
999 |
|
my $attr_options = Class::Tangram::attribute_options($classname); |
1000 |
|
#print "Attribute Options: " . Dumper($attr_options); |
1001 |
|
|
1002 |
|
my $attr_types = Class::Tangram::attribute_types($classname); |
1003 |
|
#print "Attribute Types: " . Dumper($attr_types); |
1004 |
|
|
1005 |
|
foreach(keys %{$attr_types}) { |
1006 |
|
if($attr_types->{$_} eq 'string') { |
1007 |
|
$obj->{$_} = ''; |
1008 |
|
} elsif($attr_types->{$_} eq 'int') { |
1009 |
|
$obj->{$_} = 0; |
1010 |
|
} elsif($attr_types->{$_} eq 'real') { |
1011 |
|
$obj->{$_} = 0; |
1012 |
|
} elsif($attr_types->{$_} eq 'rawdatetime') { |
1013 |
|
$obj->{$_} = '0000-00-00 00:00:00'; |
1014 |
|
} elsif($attr_types->{$_} eq 'ref') { |
1015 |
|
if($attr_options->{$_}->{class}) { |
1016 |
|
$obj->{$_} = $self->createNode($attr_options->{$_}->{class}); |
1017 |
|
} else { |
1018 |
|
#$obj->{$_} = undef(); |
1019 |
|
} |
1020 |
|
} elsif($attr_types->{$_} eq 'iarray') { |
1021 |
|
$obj->{$_} = [ ]; |
1022 |
|
} elsif($attr_types->{$_} eq 'hash') { |
1023 |
|
$obj->{$_} = { }; |
1024 |
|
} elsif($attr_types->{$_} eq 'flat_hash') { |
1025 |
|
$obj->{$_} = { }; |
1026 |
|
} |
1027 |
|
} |
1028 |
|
|
1029 |
|
#print "New Object: " . Dumper($obj); |
1030 |
|
|
1031 |
|
return $obj; |
1032 |
|
} |
1033 |
|
|
1034 |
|
|
1035 |
|
sub insertChildNode { |
1036 |
|
my $self = shift; |
1037 |
|
my $child_entry = shift; |
1038 |
|
my $query_args = shift; |
1039 |
|
|
1040 |
|
my $core = $self->{_COREHANDLE}; |
1041 |
|
my $nodename = $query_args->{nodename}; |
1042 |
|
|
1043 |
|
# get parent object |
1044 |
|
my $query = { |
1045 |
|
node => $query_args->{parent}->{nodename}, |
1046 |
|
options => { GUID => $query_args->{parent}->{guid}, }, |
1047 |
|
}; |
1048 |
|
my $cursor = $self->sendQuery($query); |
1049 |
|
my $parent = $cursor->getNextEntry(); |
1050 |
|
|
1051 |
|
# debug |
1052 |
|
#print "Parent_org: " . Dumper($parent); |
1053 |
|
|
1054 |
|
# Create child node object if isn't already done |
1055 |
|
# ($child_entry have to be the class name then...) |
1056 |
|
if(!ref($child_entry)) { |
1057 |
|
$child_entry = $self->createNode($child_entry); |
1058 |
|
# it could be insert 'manually' or will be insert 'transparent' if parent will be updated |
1059 |
|
#$core->insert($child_entry); |
1060 |
|
#print "Create child object [$nodename]: " . Dumper($child_entry); |
1061 |
|
} |
1062 |
|
|
1063 |
|
# get reference of tied node (seems, only on Linux node's are tied!!) |
1064 |
|
my $tied_node = tied $parent->{$nodename}; |
1065 |
|
|
1066 |
|
# insert/change child entry at parent |
1067 |
|
#print "reference: " . ref($parent->{$nodename}) . "\n"; |
1068 |
|
if(ref($parent->{$nodename}) eq 'ARRAY') { |
1069 |
|
# (seems, only on Linux node's are tied!!) |
1070 |
|
if($tied_node) { |
1071 |
|
# all tangram types are tied as 'SCALAR' with special 'FETCH', 'STORE' methods per type, |
1072 |
|
# so a 'PUSH' is not implemented (which could be then done transparently) |
1073 |
|
my $array = $tied_node->FETCH; |
1074 |
|
push @$array, $child_entry; |
1075 |
|
$tied_node->STORE($array); |
1076 |
|
# node will be normaly untied at 'STORE' |
1077 |
|
if(tied $parent->{$nodename}) { print "already tied !!\n"; } |
1078 |
|
else { undef $tied_node; } |
1079 |
|
} else { |
1080 |
|
push @{$parent->{$nodename}}, $child_entry; |
1081 |
|
} |
1082 |
|
} |
1083 |
|
elsif(ref($parent->{$nodename}) eq 'HASH') { |
1084 |
|
if(my $key = $query_args->{hash_key}) { |
1085 |
|
# (seems, only on Linux node's are tied!!) |
1086 |
|
if($tied_node) { |
1087 |
|
# same problem as with 'ARRAY': |
1088 |
|
# all tangram types are tied as 'SCALAR' with special 'FETCH', 'STORE' methods per type. |
1089 |
|
my $hash = $tied_node->FETCH; |
1090 |
|
$hash->{$key} = $child_entry; |
1091 |
|
$tied_node->STORE($hash); |
1092 |
|
# node will be normaly untied at 'STORE' |
1093 |
|
if(tied $parent->{$nodename}) { print "already tied !!\n"; } |
1094 |
|
else { undef $tied_node; } |
1095 |
|
} else { |
1096 |
|
$parent->{$nodename}->{$key} = $child_entry; |
1097 |
|
} |
1098 |
|
} else { |
1099 |
|
print "ERROR: No HASH KEY given, so not able to insert hash entry!"; |
1100 |
|
} |
1101 |
|
} |
1102 |
|
else { |
1103 |
|
$parent->{$nodename} = $child_entry; |
1104 |
|
} |
1105 |
|
|
1106 |
|
# debug |
1107 |
|
#print "Parent_new: " . Dumper($parent); |
1108 |
|
|
1109 |
|
# save parent |
1110 |
|
$core->update($parent); |
1111 |
|
|
1112 |
|
# debug |
1113 |
|
#print "Saved Parent: ". Dumper($parent); |
1114 |
|
|
1115 |
|
return $child_entry; |
1116 |
|
} |
1117 |
|
|
1118 |
|
|
1119 |
1; |
1; |
1120 |
__END__ |
__END__ |