cp Makeargs.debug Makeargs

gdb --directory=$A/src/cmd/dss --directory=$A/src/lib/libdss --directory=$A/src/lib/libast $A/bin/dss core.*

dss provides low level sequential ops that declarative sql typically decomposes to

what happens when the stream hits the db

CX_STRING|CX_SIZE a hack?

convert foo text to binary and compress using the preferred method:

dss -x foo-txt '{flat foo-bin}|{compress}'

sum f3..fn by f1 and f2

dss '{sum --by f1 --by f2 f3 ... fn}'

dss -xfoo option to print canonical fixed record size

dss flat add cdb sized records

<DSS>

<FIELD>

<NAME>name</>

<CONSTRAINT>name</>

<CONSTRAINT>

<NAME></>

<MIN>min</>

</>

</>

</>

cx needs array support

cxmap() should check for duplicate/clash values in item list

and between parts if possible

======================================================

field name aliases

cxparse

, not handled right

; not handled right

rfc 2280

====================================================

Proposal for prefix/address set manipulation

====================================================

We have two distinct types of sets : prefix sets

and address sets. Prefix sets are sets of CIDR

prefixes, while address sets are sets of IP addresses.

I'll use the following conventions:

A, B, C : prefix sets

X, Y, Z : address sets

Set operations

==============

Set operations defined on both (overloaded)

prefix and address sets. Each must have

operands of the same type, and each preserves that type.

union : A+B, X+Y

intersection : A&B, X&Y

difference : A-B, X-Y

The negation operator, ~X, is only defined on address sets.

[Note : we could define ~A in the obvious way, but the space

of all prefixes does not seem to be an interesting one.]

Constructors

==================

1) prefix_set {p1 p2 ... pn} (n>=0, where each pi is a CIDR block)

2) address_set {a1 a2 ... an} (n>=0, where each ai is an IP address)

Basic conversions

=================

addresses(A) = X

X is the address set representing the IP addresses

covered by the prefixes in A.

prefixes(X) = A

A is the minimal prefix cover of the address space of X.

Operations on prefix sets

=========================

supernets(A) = B

B is the subset of A that covers the same space

(that is, addresses(supernets(A)) == addresses(A)), but no prefix

of B is a subnet of another prefix of B.

longest(A, B) = C

C is the subset of prefixes A which are the longest

matches for prefixes in B. That is, p1 is in C iff

p1 is in A and there exist p2 in B such that p1 "contains" p2

and there is no p3 in A such that p1 contains p3 and p3 contains p2.

(Note : it could be that p1 == p2.)

Here are some useful abbreviations :

min_cover(A) = B

B is the minimum prefix cover required to cover the same space

as covered by A.

Is abbreviation for prefixes(addresses(A)).

shortest(A, B) = C

C is the subset of prefixes A that are the shortest

matches for some prefix in B.

An abbreviation for longest(supernets(A), B).

subnets(A) = B

B is the set of prefixes in B that are properly

contained in other prefixes of B.

An abbreviation of A - supernets(A).

Operations for extracting prefix sets from BGP tables

=====================================================

... like current, except prefix sets get extracted ...

=================================================

Some open questions.

=================================================

0) Are there other basic operators required?

1) Should we add another set type : range set?

2) Do we want to have a set type : route set?

This would be a set of BGP routes, perhaps

with additional attributes (like timestamp,

router name, AS of router).