tokkee.org

Renamed CONNECTION_* constants to SDB_CONNECTION_*.

All public symbols should use the "sdb" prefix.

data: Support array + element concatenation.

That is, concatenation may be used to prepend to or append to an array.

data: Let strlen() and format() support string/decimal/integer arrays.

core: Improved style related to conditionals using many branches.

sysdbql(7): Documented iterator support for arrays.

store: Avoid unnecessary data copies when "evaluating" constant values.

store: Let array iterators support regex matches as well.

That is, all operators are supported now.

store: Let NREGEX (!~) not match on NULL values.

parser_test: Added various ANY/ALL iterator tests; also for arrays.

data: Don't treat empty arrays (value = NULL) as NULL.

Treating them as NULL leads to weird behavior when using ANY/ALL iterators.

store, frontend: Added support for iterating arrays (using ALL / ANY).

Currently, this is limited to the 'backend' field of an object. Also, only
simple statements like 'ANY/ALL <array> <cmp> <value>' are supported by the
store (in contrast to service/metric iterators which support arbitrary
matchers to be applied). Given that matchers are object based, this limitation
should feel natural, though.

store.h: Use separate value ranges for object and field types.

This allows to use the same flag to store either object or field types or even
a combination of both.

store: Merged implementations of compare matchers.

This allowed to factor out the actual comparison functionality, thus making it
reusable.

data: Added sdb_data_array_get().

This function retrieves an array element, returning an "alias" to its value.

sysdbql(7): Updated documentation according to latest language changes.

Lots of stuff has changed … and it's much better now :-)

frontend/grammar: Drop support for the special 'host' field.

The old implementation didn't work when querying services or metrics and for
hosts it's the same as querying the 'name' field.

frontend/grammar: Let LOOKUP support all object types.

frontend: Let the 'lookup' command support services and metrics.

store_lookup: Let the iter operators support services and metrics.

frontend: Let the analyzer report details about errors.

data: Add to-string support for array types.

frontend: Improved parser error reporting.

All error messages are now written to a string buffer, allowing them to be
displayed as part of the main error messages associated with failed commands.

frontend/grammar: Added sdb_fe_yyerrorf() helper.

utils/error: Added sdb_vlog().

This function is like sdb_log() but accept a va_list.

frontend/grammar: Added support for FETCHing all object types.

frontend: Let the parser run the analyzer.

… but only when parsing a full statement. Otherwise, the analyzer is missing
the context for verification.

parser_test: Fixed semantically invalid filter statements.

These errors are only detected by the analyzer which is not used for the
parser test.

frontend/analyzer: Check name parameters for FETCH.

frontend: Fixed various size checks.

frontend: Let the 'fetch' command support other types besides hosts.

store: Added sdb_store_get_child().

This function may be used to retrieve a host's child object (service, metric,
attribute) by it's name.

store: Removed now unused tojson functions.

frontend: Let FETCH and LIST use JSON formatters.

… instead of the old tojson functions.

frontend: Let FETCH apply filters to the host as well.

store: Let JSON formatter know about the to-be-formatted object type.

When formatting services or metrics, expect those objects to be emitted on the
highest level and then create the host object for them first (once for a
series of objects belonging to the same host).

store: Let the JSON formatter know about arrays at top level.

There's no reason to require this to be handled separately.

t/: Added tests for json_formatter-based JSON generation.

store: Record each object's parent.

frontend/query: Use the new JSON formatter to implement LOOKUP.

This will allow for more flexiblity.

store: Added a generic JSON formatter.

It works by consuming single objects of any type (host, service, metric,
attribute) at a time and appending their JSON serialization to a string
buffer. The current position in the object tree is recorded in an internal
state.

A helper function is provided on top of the base formatter which allows to
handle an full object at a time.

store: Provide more verbose messages on errors during scanning.

store_lookup_test: Ensure that filters are applied before matchers.

sysdbql(7): Link to the JSON RFC.

store: Let sdb_store_scan() pass on filters to callback functions.

The callback function needs access to the filter anyway, so let's handle this
centrally.

store: Use sdb_avltree_lookup() to retrieve attributes.

… rather than iterating through all attributes. D'oh!

store: Let sdb_store_scan() support other object types besides hosts.

store: Merged sdb_store_iterate() into sdb_store_scan().

These functions are really the same when using a NULL matcher and filter.

frontend: Added basic support for semantic AST analysis.

For now, the analyzer checks the types of all matcher operands.

frontend: Let scanner/parser know about object types and field names.

This allows to handle all known objects and fields as part of the grammar
rather than manually parsing them and generating custom error messages.

frontend/grammar: Access fields by their name rather than '.<name>'.

There's no more need for a special and somewhat weird syntax.

frontend/grammar: Added support for 'ALL <obj> <cmp> <expr>'.

This matches, if all of the specified objects match the specified expression.
ALL also matches on empty object lists.

store: Removed unused types.

store: Added support for ALL matchers.

Similar to ANY, this matcher iterators over objects. It matches, if *all* of
those objects match another matcher.

store: Don't special case negated matchers in the ANY matcher.

The old behavior no longer makes sense when thinking about matching *any*
object.

frontend/grammar: Changed '<obj> <cmp> <expr>' to 'ANY <obj> <cmp> <expr>'.

… for services, metrics, and attributes. That is, let this involve less magic
but make it clear that this looks at multiple objects and matches if any of
them match.

store: Renamed child-matcher to any-matcher.

It matches if any object of an iterable list matches, so this is a more
appropriate name.

data_test: Test various unsupported expressions.

store: During lookup use strcmp() only for unknown data-types.

Unknown data-types means that we don't know the type of either one expression
before hand. For example, this is true for attributes given that there is no
schema.

store: Record the data-type of an expression.

data: Added sdb_data_expr_type().

This function returns the expected type of the result of an arithmetic
expression based on the operator and input types.

store: Removed now unused name-matcher and sdb_store_matcher_parse_cmp().

t/: Converted name matcher tests to new style matchers.

frontend/grammar: Implement '<obj> <op> <expr>' using new-style matchers.

store: Added sdb_store_parse_object_type().

This function parses an object type name (singular) and returns the type ID.

store: Let sdb_store_parse_object_type_plural support attributes.

However, the parser will not accept attributes in LIST commands as before.
Still, an attribute is considered to be a stored object.

store: Let child matchers handle negated operators as before.

That is, negated matchers have to match *all* children because a condition
like "service != 'foo'" would match only on hosts which do not have a service
called 'foo'.

store: Let child matcher actually match the child.

store: Fixed a typo in the type check of the child matcher.

store: Removed unused old sdb_store_attr_matcher().

store: Renamed sdb_store_cmp_XX to sdb_store_XX_matcher.

… now that these names have become available again.

store: Removed unused, old conditional matchers.

store: Removed now unused support for attribute matchers in old code.

t/: Use expression-based matchers for attribute comparison tests.

store: Removed sdb_store_matcher_parse_field_cmp() and sdb_store_obj_cond().

Those functions have been superseded by the new expression-based matchers.

t/: Use the new expression-based matchers for various tests.

data: Format NULL as NULL and never quote it.

The idea, previously, was to make NULL values easily identifiable in all
messages but the focus really is on the JSON output which supports a real null
value.

store: Let NULL values never match a regex.

store: Removed sdb_store_matcher_tostring().

This function was mainly used for debugging and more verbose error messages
upon test failures. Given that we have more fine-grained tests now, keeping
the tostring() methods up-to-date is rather annoying but for little benefit.

Instead, we should have a real pretty-printer or similar at some point.

frontend/grammar: Unified field and attribute value matchers.

Use generic expressions and the new compare matchers instead.

As a side-effect of this change, not-operators (!=, etc.) no longer match on
NULL values (attribute does not exist). This is intended and should have been
like this in the first place (we've got 'IS NULL' for that purpose). For
example, `attribute['foo'] != 123' did previously match if attribute 'foo' did
not exist but now this is no longer the case.

store: Let compare matchers fail if any of the operands is NULL.

t/: Let tests use '<expr> IN .backend'.

frontend/grammar: Added support for the IN operator.

This is a matcher checking if a value is included in an array. It's mostly
meant to be used to match backends at the moment.

store: Added sdb_store_in_matcher().

This function creates a matcher which matches if the right value evaluates to
an array value and the left value is included in that array.

data: Added sdb_data_inarray().

The function determines whether a value is included in an array.

store: Added support for querying the BACKEND field.

… returning an array of strings.

data: Added support for comparing integer, decimal, and string arrays.

Array comparison works element-by-element, returning how the first non-equal
elements compare to each other.

Added tests for array comparison and concatenation.

data_test: Use int64_t instead of int for integer array data.

data: Fixed length of newly allocated array in concat().

data: Added basic support for arrays.

An array may contain elements of one type and it's stored in compact raw form
(as in: not an array of union values but an array of the actual values).
'copy', 'free', and 'concat' operations are currently supported but limited to
integer, decimal, or string element types. ENOTSUP is returned for any other
operations.

data_test: Removed unnecessary and possibly misleading checks.

data: Use if-statements rather than switch-statements.

data: Added sdb_data_sizeof().

This function returns the size of the data-type for a given type.

store: Clarify behavior of expr_attrvalue if the attribute does not exist.

frontend/grammar: Fixed parsing of 'attribute[<string>]'.

That is, don't accept anything besides the string "attribute". Previously,
<anything>[<string>] was accepted as an attribute value.

frontend/grammar: Make IS NULL operators available to any expression.

store: Return NULL if an attribute was not found.

data: Added explicit NULL values.

… and let all expressions involving NULL values to return NULL.

data: Let CONCAT return NULL if any of its operands is NULL.

This mimics behavior in SQL and also allows for missing values to be reported
as NULL and propagate that information.

frontend/grammar: Use strings to access attribute value: attribute['name'].

store, frontend: Make IS (NOT) NULL an unary operator on expressions.

This is more flexible and in-line with all other operators being migrated to
expression-based constructs.