Category Archives: Andl.Net

Working surprisingly well. As purely a query language, it has:

• Equals, subset, distinct
• Where
• Select (combines Rename, Project, Extend)
• Set ops: union, minus, intersect, symdiff
• Join and Antijoin
• Order by (for export purposes)
• Skip Take

The code looks like this:

      class TT1 : NdlTuple<TT1> {
      public string A2;
      public int A1;
      public decimal A3;
      public static TT1[] R1() {
        return new TT1[] {
          new TT1 { A1 = 42, A2 = "hello", A3 = 1.2m },
          new TT1 { A1 = 42, A2 = "world", A3 = 1.2m },
        };
      }
      public static NdlRelation<TT1> NDR_1() {
        return new NdlRelation<TT1>(R1());
      }
    }

    var v1 = TT1.NDR_1();
    var v2 = v1.Where(t => t.A1 == 42);
    var v3 = v2.Select(t => new TT2 { A1 = t.A1, A2 = "constant", A3 = t.A3 });

I’m making heavy use of NUnit and finding plenty of bugs. No updates yet; no data import; no aggregation; no while/recursion; no ordered queries. But it all seems surprisingly possible, even without a lot of help from the compiler. And much easier than writing compilers.

To recap: this is about attempting to reproduce the essential capabiities of Andl (based on TTM/D) as a set of extensions to a standard OO language. I am using C#, but my comments should apply equally to Java, C++, Rust, Dlang, Go, etc.

In my opinion the TTM/D type system can be substantially reproduced as follows.

1. Scalar types: the requirements are satisfied by any type that is immutable and provides value semantics. In practice this means a class in which:

• All members are (recursively) scalar, tuple or relation types
• Members can only be set to a value at construction time
• Operator ‘=’ implements equality of value
• The hash value depends only on the value (therefore is constant)

2. Tuple types: the requirements are satisfied by a type that is immutable and has value semantics, and also:

• All members are scalar types or (recursively) tuple types
• Operator ‘=’ implements equality of value by member name (only if same heading)
• The hash value depends only on the value (therefore is constant)
• A value can be created by member-wise copy of another tuple type (only if same heading)

3. Relation types: the requirements are satisfied by a type that:

• Can provide an enumerator over tuple types for others to use
• All operations on relations are then implemented by enumerating streams of tuples (pipelining).

4. Relvar: an object of relational type with the additional feature that:

• It can accept an enumeration over tuple types and apply it to a persistence store.

Tuple types are the core of the system. In the absence of compiler support, every tuple type consumed or emitted by any relational operator has to be individually declared, but the common functionality comes from inheriting a base class and related interfaces.

Relation types are interesting. A lengthy sequence of operations of the Relational Algebra is just a set of chained functions calls and enumerators. It does not in fact cause any processing of data until a caller either (a) retrieves data to be sent elsewhere or (b) commits a transaction. A relvar is a relation type from which an enumerator can be obtained and which accepts updates. It is not a collection, just an adapter to someone else’s collection.

I have a crude but working implementation (and I have learned a lot about C# generics). Still hard to tell whether it leads anywhere, but I should be able to hook it up to the Andl database backend and then we’ll see. An Sql implementation can then generate Sql and enumerate the result set instead of the raw data (Andl does that).