Changeset 18093 for ext

Timestamp:

09/22/07 09:55:46 (16 months ago)

Author:

Darren_Duncan

Message:

ext/Muldis-DB/ : some minimal compatibility updates to PhysType?.pm and Operators.pm

Location:

ext/Muldis-DB

Files:

• Changes (modified) (2 diffs)
• lib/Muldis/DB/Engine/Example/Operators.pm (modified) (7 diffs)
• lib/Muldis/DB/Engine/Example/PhysType.pm (modified) (26 diffs)

ext/Muldis-DB/Changes

@@ -10 +10 @@
     which sets its own less frequent release schedule.  The rest of this
     Changes entry refers only to the Perl 5 version.
+
+    * This release is a snapshot to show a particular mid-way point in a
+    large sequence of changes.  To summarize, the public API of Muldis DB
+    has been rewritten, documentation for that API was added (including an
+    example), and both the Example Engine and the Validator suite were
+    (substantially) updated to conform to the new API.  However, the
+    Example Engine is still incapable of executing any tasks, so that
+    aspect is unchanged from before.  The next release should flesh out
+    Example so that it executes some tasks.
 
     * Removed the file Literal.pm; Muldis DB now uses Perl Hosted Abstract
@@ -74 +83 @@
 
     * (Example.pm)  Rewrote the Example.pm code to conform to the changed
-    API declared by Interface.pm.  TODO: FINISH THIS.
+    API declared by Interface.pm.  The new version implements the root
+    module, the ::DBMS and ::Var classes, but not the ::(Func|Proc)Binding
+    classes.  Also, the interface-role implementing classes were all
+    renamed aside from interface-conformity, specifically "::Public" was
+    added to all their names, that signifying that these are the only
+    classes that applications would directly invoke.  This file stands to
+    be substantially updated in the next releases, but for the most part
+    most Example code will be put in other files, with Example.pm limited
+    to providing just the public interface.
+
+    * (PhysType.pm, Operators.pm)  Made a minimal set of updates to these
+    files to bring them up to date with the current Muldis D type or
+    routine names for what they implement, and to remove any references to
+    Literal.pm.  These files stand to be substantially updated, or even
+    replaced in the next releases.
 
     * (SeeAlso.pod)  Updated the PROSPECTIVE MULDIS DB EXTENSIONS section

ext/Muldis-DB/lib/Muldis/DB/Engine/Example/Operators.pm

@@ -15 +15 @@
 ###########################################################################
 
-## sys.type.Bool ##
+## sys.Core.Universal.Universal ##
 
-
-## sys.type.Order ##
-
-
-## sys.type.Int ##
-
-'sys.rtn.Int.equal' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Universal.is_equal' => sub ($dbms!, Hash $ro_args!) {
     my ($v1, $v2) = $ro_args<v1 v2>;
     return ptBool( :v($v1.equal( $v2 )) );
 },
 
-'sys.rtn.Int.not_equal' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Universal.is_not_equal' => sub ($dbms!, Hash $ro_args!) {
     my ($v1, $v2) = $ro_args<v1 v2>;
     return ptBool( :v(!$v1.equal( $v2 )) );
 },
 
-'sys.rtn.Int.assign' => sub ($dbms!, Hash $upd_args!, Hash $ro_args!) {
+'sys.Core.Universal.assign'
+        => sub ($dbms!, Hash $upd_args!, Hash $ro_args!) {
     my ($target) = $upd_args<target>;
     my ($v) = $ro_args<v>;
@@ -40 +35 @@
 },
 
-'sys.rtn.Int.sum' => sub ($dbms!, Hash $ro_args!) {
+## sys.Core.Bool.Bool ##
+
+
+## sys.Core.Order.Order ##
+
+
+## sys.Core.Int.Int ##
+
+'sys.Core.Int.sum' => sub ($dbms!, Hash $ro_args!) {
     my ($addends) = $ro_args<addends>;
     my Int $sum = 0;
@@ -49 +52 @@
 },
 
-'sys.rtn.Int.difference' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.difference' => sub ($dbms!, Hash $ro_args!) {
     my ($minuend, $subtrahend) = $ro_args<minuend subtrahend>;
     return ptInt( :v($minuend.v() - $subtrahend.v()) );
 },
 
-'sys.rtn.Int.product' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.product' => sub ($dbms!, Hash $ro_args!) {
     my ($factors) = $ro_args<factors>;
     my Int $product = 1;
@@ -63 +66 @@
 },
 
-'sys.rtn.Int.quotient' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.quotient' => sub ($dbms!, Hash $ro_args!) {
     my ($dividend, $divisor) = $ro_args<dividend divisor>;
     my Int $divisor_v = $divisor.v();
-    die q{sys.rtn.Int.quotient(): Arg :$divisor is zero.}
+    die q{sys.Core.Int.quotient(): Arg :$divisor is zero.}
         if $divisor_v === 0;
 #    return ptInt( :v(floor ($dividend.v() div $divisor_v)) );
@@ -72 +75 @@
 },
 
-'sys.rtn.Int.remainder' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.remainder' => sub ($dbms!, Hash $ro_args!) {
     my ($dividend, $divisor) = $ro_args<dividend divisor>;
     my Int $divisor_v = $divisor.v();
-    die q{sys.rtn.Int.remainder(): Arg :$divisor is zero.}
+    die q{sys.Core.Int.remainder(): Arg :$divisor is zero.}
         if $divisor_v === 0;
 #    return ptInt( :v($dividend.v() mod $divisor_v) );
@@ -81 +84 @@
 },
 
-'sys.rtn.Int.abs' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.abs' => sub ($dbms!, Hash $ro_args!) {
     my ($v) = $ro_args<v>;
     return ptInt( :v(abs $v.v()) );
 },
 
-'sys.rtn.Int.power' => sub ($dbms!, Hash $ro_args!) {
+'sys.Core.Int.power' => sub ($dbms!, Hash $ro_args!) {
     my ($radix, $exponent) = $ro_args<radix exponent>;
     return ptInt( :v($radix.v() ** $exponent.v()) );
 },
 
-## sys.type.Blob ##
+## sys.Core.Num.Num ##
 
 
-## sys.type.Text ##
+## sys.Core.Blob.Blob ##
 
 
-## sys.type.Tuple ##
+## sys.Core.Text.Text ##
 
 
-## sys.type.Relation ##
+## sys.Core.Tuple.Tuple ##
+
+
+## sys.Core.Relation.Relation ##
 
 
@@ -142 +148 @@
 all Muldis D implementations must have, which is the selectors for and
 general purpose functions and update operators for these data types: Bool,
-Text, Blob, Int, Num, Tuple, Relation, and the Cat.* types.
+Order, Int, Num, Text, Blob, Tuple, Relation, and the Cat.* types.
 
 By contrast, the operators specific to the optional data types are

ext/Muldis-DB/lib/Muldis/DB/Engine/Example/PhysType.pm

@@ -217 +217 @@
 
 method root_type of Str () {
-    return 'sys.type.Bool';
+    return 'sys.Core.Bool.Bool';
 }
 
@@ -223 +223 @@
     if (!$!which.defined) {
         my Str $s = ~$!v;
-        $!which = "13 sys.type.Bool {$s.graphs} $s";
+        $!which = "18 sys.Core.Bool.Bool {$s.graphs} $s";
     }
     return $!which;
@@ -230 +230 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::Bool () {
-    return ::Muldis::DB::Literal::Bool.new( :v($!v) );
+method as_ast of Muldis::DB::LOSE::Bool () {
+    return ::Muldis::DB::LOSE::Bool.new( :v($!v) );
 }
 
@@ -270 +270 @@
 
 method root_type of Str () {
-    return 'sys.type.Order';
+    return 'sys.Core.Order.Order';
 }
 
@@ -276 +276 @@
     if (!$!which.defined) {
         my Str $s = ~$!v;
-        $!which = "14 sys.type.Order {$s.graphs} $s";
+        $!which = "20 sys.Core.Order.Order {$s.graphs} $s";
     }
     return $!which;
@@ -283 +283 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::Order () {
-    return ::Muldis::DB::Literal::Order.new( :v($!v) );
+method as_ast of Muldis::DB::LOSE::Order () {
+    return ::Muldis::DB::LOSE::Order.new( :v($!v) );
 }
 
@@ -323 +323 @@
 
 method root_type of Str () {
-    return 'sys.type.Int';
+    return 'sys.Core.Int.Int';
 }
 
@@ -329 +329 @@
     if (!$!which.defined) {
         my Str $s = ~$!v;
-        $!which = "12 sys.type.Int {$s.graphs} $s";
+        $!which = "16 sys.Core.Int.Int {$s.graphs} $s";
     }
     return $!which;
@@ -336 +336 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::Int () {
-    return ::Muldis::DB::Literal::Int.new( :v($!v) );
+method as_ast of Muldis::DB::LOSE::Int () {
+    return ::Muldis::DB::LOSE::Int.new( :v($!v) );
 }
 
@@ -376 +376 @@
 
 method root_type of Str () {
-    return 'sys.type.Blob';
+    return 'sys.Core.Blob.Blob';
 }
 
@@ -382 +382 @@
     if (!$!which.defined) {
         my Str $s = ~$!v;
-        $!which = "13 sys.type.Blob {$s.graphs} $s";
+        $!which = "18 sys.Core.Blob.Blob {$s.graphs} $s";
     }
     return $!which;
@@ -389 +389 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::Blob () {
-    return ::Muldis::DB::Literal::Blob.new( :v($!v) );
+method as_ast of Muldis::DB::LOSE::Blob () {
+    return ::Muldis::DB::LOSE::Blob.new( :v($!v) );
 }
 
@@ -429 +429 @@
 
 method root_type of Str () {
-    return 'sys.type.Text';
+    return 'sys.Core.Text.Text';
 }
 
@@ -435 +435 @@
     if (!$!which.defined) {
         my Str $s = $!v;
-        $!which = "13 sys.type.Text {$s.graphs} $s";
+        $!which = "18 sys.Core.Text.Text {$s.graphs} $s";
     }
     return $!which;
@@ -442 +442 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::Text () {
-    return ::Muldis::DB::Literal::Text.new( :v($!v) );
+method as_ast of Muldis::DB::LOSE::Text () {
+    return ::Muldis::DB::LOSE::Text.new( :v($!v) );
 }
 
@@ -486 +486 @@
 
 method root_type of Str () {
-    return 'sys.type.' ~ (self._allows_quasi() ?? 'Quasi' !! '') ~ 'Tuple';
+    my $unqltp = ($self->_allows_quasi() ?? 'Quasi' !! '') ~ 'Tuple';
+    return "sys.Core.$unqltp.$unqltp";
 }
 
 method which of Str () {
     if (!$!which.defined) {
-        my Str $root_type = 'sys.type.'
-            ~ (self._allows_quasi() ?? 'Quasi' !! '') ~ 'Tuple';
+        my $unqltp = ($self->_allows_quasi() ?? 'Quasi' !! '') ~ 'Tuple';
+        my Str $root_type = "sys.Core.$unqltp.$unqltp";
         my Str $tpwl = $root_type.graphs ~ q{ } ~ $root_type;
         my Str $s = "H {$!heading.which()} B {$!body.which()}";
@@ -502 +503 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::_Tuple () {
+method as_ast of Muldis::DB::LOSE::_Tuple () {
     my $call_args = \( :heading($!heading.as_ast()),
         :body($!body.as_ast()) );
     return self._allows_quasi()
-        ?? ::Muldis::DB::Literal::QuasiTuple.new.callwith( |$call_args )
-        !! ::Muldis::DB::Literal::Tuple.new.callwith( |$call_args );
+        ?? ::Muldis::DB::LOSE::QuasiTuple.new.callwith( |$call_args )
+        !! ::Muldis::DB::LOSE::Tuple.new.callwith( |$call_args );
 }
 
@@ -599 +600 @@
 
 method root_type of Str () {
-    return
-        'sys.type.' ~ (self._allows_quasi() ?? 'Quasi' !! '') ~ 'Relation';
+    my $unqltp = ($self->_allows_quasi() ?? 'Quasi' !! '') ~ 'Relation';
+    return "sys.Core.$unqltp.$unqltp";
 }
 
 method which of Str () {
     if (!$!which.defined) {
-        my Str $root_type = 'sys.type.'
-            ~ (self._allows_quasi() ?? 'Quasi' !! '') ~ 'Relation';
+        my $unqltp
+            = ($self->_allows_quasi() ?? 'Quasi' !! '') ~ 'Relation';
+        my Str $root_type = "sys.Core.$unqltp.$unqltp";
         my Str $tpwl = $root_type.graphs ~ q{ } ~ $root_type;
         my Str $s = "H {$!heading.which()} B "
@@ -617 +619 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::_Relation () {
+method as_ast of Muldis::DB::LOSE::_Relation () {
     my $call_args = \( :heading($!heading.as_ast()),
         :body([$!body.map:{ .as_ast() }]) );
     return self._allows_quasi()
-        ?? ::Muldis::DB::Literal::QuasiRelation.new.callwith( |$call_args )
-        !! ::Muldis::DB::Literal::Relation.new.callwith( |$call_args );
+        ?? ::Muldis::DB::LOSE::QuasiRelation.new.callwith( |$call_args )
+        !! ::Muldis::DB::LOSE::Relation.new.callwith( |$call_args );
 }
 
@@ -720 +722 @@
 
 method root_type of Str () {
-    return 'sys.type._TypeInvo' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
+    return 'sys.LOSE._TypeInvo' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
 }
 
 method which of Str () {
     if (!$!which.defined) {
-        my Str $tpwl = '20 sys.type._TypeInvo'
+        my Str $tpwl = '20 sys.LOSE._TypeInvo'
             ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
         my Str $sk = $!kind.graphs ~ q{ } ~ $!kind;
@@ -738 +740 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::_TypeInvo () {
+method as_ast of Muldis::DB::LOSE::_TypeInvo () {
     my $call_args = \( :kind($!kind),
         :spec($!kind === 'Any' ?? $!spec
-            !! $!kind === 'Scalar' ?? ::Muldis::DB::Literal::EntityName.new( :text($!spec) )
+            !! $!kind === 'Scalar' ?? ::Muldis::DB::LOSE::EntityName.new( :text($!spec) )
             !! $!spec.as_ast()) );
     return self._allows_quasi()
-        ?? ::Muldis::DB::Literal::QuasiTypeInvo.new.callwith( |$call_args )
-        !! ::Muldis::DB::Literal::TypeInvo.new.callwith( |$call_args );
+        ?? ::Muldis::DB::LOSE::QuasiTypeInvo.new.callwith( |$call_args )
+        !! ::Muldis::DB::LOSE::TypeInvo.new.callwith( |$call_args );
 }
 
@@ -812 +814 @@
 
 method root_type of Str () {
-    return 'sys.type._TypeDict' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
+    return 'sys.LOSE._TypeDict' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
 }
 
 method which of Str () {
     if (!$!which.defined) {
-        my Str $tpwl = '20 sys.type._TypeDict'
+        my Str $tpwl = '20 sys.LOSE._TypeDict'
             ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
         my Str $s = $!map.pairs.sort.map:{
@@ -829 +831 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::_TypeDict () {
+method as_ast of Muldis::DB::LOSE::_TypeDict () {
     my $call_args = \( :map([ $!map.pairs.map:{
-            [::Muldis::DB::Literal::EntityName.new( :text(.key) ), .value.as_ast()],
+            [::Muldis::DB::LOSE::EntityName.new( :text(.key) ), .value.as_ast()],
         } ]) );
     return self._allows_quasi()
-        ?? ::Muldis::DB::Literal::QuasiTypeDict.new.callwith( |$call_args )
-        !! ::Muldis::DB::Literal::TypeDict.new.callwith( |$call_args );
+        ?? ::Muldis::DB::LOSE::QuasiTypeDict.new.callwith( |$call_args )
+        !! ::Muldis::DB::LOSE::TypeDict.new.callwith( |$call_args );
 }
 
@@ -917 +919 @@
 
 method root_type of Str () {
-    return 'sys.type._ValueDict' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
+    return 'sys.LOSE._ValueDict' ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
 }
 
 method which of Str () {
     if (!$!which.defined) {
-        my Str $tpwl = '20 sys.type._ValueDict'
+        my Str $tpwl = '20 sys.LOSE._ValueDict'
             ~ (self._allows_quasi() ?? 'AQ' !! 'NQ');
         my Str $s = $!map.pairs.sort.map:{
@@ -934 +936 @@
 ###########################################################################
 
-method as_ast of Muldis::DB::Literal::_ExprDict () {
-    return ::Muldis::DB::Literal::_ExprDict.new( :map([ $!map.pairs.map:{
-            [::Muldis::DB::Literal::EntityName.new( :text(.key) ), .value.as_ast()],
+method as_ast of Muldis::DB::LOSE::_ExprDict () {
+    return ::Muldis::DB::LOSE::_ExprDict.new( :map([ $!map.pairs.map:{
+            [::Muldis::DB::LOSE::EntityName.new( :text(.key) ), .value.as_ast()],
         } ]) );
 }
@@ -1029 +1031 @@
 
 Specifically, this file represents the core system-defined data types that
-all Muldis D implementations must have, namely: Bool, Text, Blob, Int, Num,
-Tuple, Relation, and the Cat.* types.
+all Muldis D implementations must have, namely: Bool, Order, Int, Num,
+Text, Blob, Tuple, Relation, and the Cat.* types.
 
 By contrast, the optional data types are given physical representations by