dbappbuilder-relannounce — Announcements of Rel releases and crucial bugs. Low volume.

[Dbappbuilder-relannounce] Rel version 3.016 now available!

[Rel a. list. <dba...@li...>]

This release of Rel, an implementation of Date & Darwen’s Tutorial D database language, fixes a bug that prevented the Rel DBMS ‘BACKUP’ command working and thus prevented correct operation of DBrowser’s backup facility, and changes the schema of the sys.Version relvar.

Fix: Reorganisation of the Rel build infrastructure inadvertently made the internal backup script inaccessible. This has been corrected, so backups — whether via DBrowser or BACKUP command — should now work.
Enhancement: The format of the sys.Version relvar has been simplified to remove the multiple version attributes and replace them with two attributes: db_version for the database format, and product_version for the release version.
Enhancement: Spelling changed from ‘updateable’ to ‘updatable’ in error messages where it appears, to be consistent with typical use.
For more information, or to download Rel, go to https://reldb.org <https://reldb.org/>

[Dbappbuilder-relannounce] Rel version 3.015 now available!

[Rel a. list. <dba...@li...>]

This release of Rel, an implementation of Date & Darwen’s Tutorial D database language, upgrades some dependencies, adds more detailed logging to the DBrowser startup, fixes some issues, and provides a Maven-based build for Rel developers.

The following enhancements have been made:

Enhancement: Update to Java 19.
Enhancement: Upgraded 3rd party libraries.
Enhancement: Added more detailed startup diagnostic logging.
Enhancement: Java build uses Maven. Ant and Eclipse not required.
The following issues have been addressed:

Fix: A bogus preference key starting with \u0000 may have been inserted into the .rel preferences file. It is removed if present.
Fix: Recently-used database list now limited to 25 databases, to prevent startup slowdown and possible resource limit issues.
Fix: The DUP_COUNT option for external JDBC-based relvars has been fixed. Previously, it returned incorrect values.
For more information, or to download Rel, go to https://reldb.org <https://reldb.org/>

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.012 now available.

[Rel a. list. <dba...@li...>]

This release of Rel, an implementation of Date & Darwen’s Tutorial D database language, improves the user interface and fixes some bugs.

The following enhancements have been made:

– Rel DBMS: Now provides -q command-line option to disable startup/shutdown information messages. This is intended to make it easier to implement standalone scripts that produce console output for later redirection.

– Rel UI: Tabular displays of views, relvars, or expression evaluation results (in the Rev visual query editor) now provide mechanism to search and sort the results.

– Rev visual query editor: Advanced search available in Restrict (WHERE) operator.

– Rev visual query editor: A Comment node has been provided, to add commentary to a visual query.

– Rel DBMS: new built-in operator SEARCH(t TUPLE{*}, regex CHAR) RETURNS BOOLEAN, which returns true if any CAST_AS_CHAR(a), where a is an attribute of t, matches regex. This permits general text search of tuples, e.g., S WHERE SEARCH(TUP {*}, “.*3.*”) returns any tuple in S with a ‘3’ in some attribute value.

The following bugs have been fixed:

– Rel UI: In the command-line interface, attempting to execute a statement like WRITELN “blah//”; — or other statement with a string with an embedded comment character sequence — caused a syntax error, because // was treated as an expression ending in a comment rather than a statement. Fixed.

For more information, or to download Rel, go to https://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.011 now available.

[Rel a. list. <dba...@li...>]

This release of Rel, an implementation of Date & Darwen's Tutorial D database language, improves the user interface and fixes some bugs.

The following enhancements have been made:

- Rel UI: Opening a relvar in Edit mode now positions the cursor in the blank row at the bottom, ready to enter a new tuple.  Cursor keys may be used to navigate, and Ctrl/Cmd-Cursor keys may be used to jump to top/bottom or right/left.

- Rel UI: Font scaling has been improved when using alternative output display on HiDPI Windows displays.

- Rel UI: The bundled Java runtime is now version 8u161.

- Rel DBMS: Using SAME_HEADING_AS(...) in a relation literal heading was previously not permitted. E.g., REL SAME_HEADING_AS(S) {} was a syntax error.  It is now permitted.
  
- Rel DBMS and Rel Client now check for and correctly handle 'null' source code.

The following bugs have been fixed:

- Rel UI: Cut/copy/paste/selectAll drop-down menus and keyboard shortcuts now work consistently and are generally available wherever they should appear.

- Rel DBMS: ABS(n) always returned a RATIONAL value, even if n was INTEGER. Fixed.

- Rel UI: 

  Given: Ubuntu 16.xx, 17.xx and other GTK3 environments.

  Result: Multiple GUI failures similar to those when using the
  Eclipse IDE under GTK3.

  Fixed. Startup forces GTK2. Some issues remain, but at least it's
  usable.

- Rel UI: 

  Given: In the relvar Edit mode, press "Go to INSERT row" button on
  relvar with high enough cardinality to require scrolling.
	
  Result: It was was supposed to do what Ctrl-End should also do:
  position the display on the blank row and put the cursor in it. It
  doesn't.
	
  Fixed. Ctrl-Cursor preferred over Ctrl-End.

- Rev:
	
  Given: Create an Expression and set its text to "WRITELN '&blah'".

  Result: The & won't show. If you change the text to "WRITELN
  '&&blah'", it shows &, but is treated as "WRITELN '&&blah'".  

  Fixed.
  			
- Rel DBMS:
	
  Given: https://reldb.org/forum/viewtopic.php?f=2&t=1527&p=2863#p2863 <https://reldb.org/forum/viewtopic.php?f=2&t=1527&p=2863#p2863>
	
  Result: Fatal error instead of semantic error.
	
  Fix: Now throws semantic error, plus gives a helpful hint for fixing
  a typical error.

- Rel DBMS:

  Given: S GROUP {blah} AS rva
	
  Result: Java NullPointerException due to undefined attribute 'blah'.
	
  Fixed.

For more information, or to download Rel, go to https://reldb.org <https://reldb.org/>

Re: [Dbappbuilder-relannounce] [TTM] ANNOUNCE: Rel version 3.010 now available!

[Rel a. list. <dba...@li...>]

On 6 Dec 2017, at 22:25, David Bennett <da...@yo...> wrote:

> Just one question:
>  
> - fix: DBMS:
>   Given:
>             COUNT {S WHERE CITY = CITY, S WHERE STATUS = STATUS}
>    Result:
>             Returns type mismatch error when it shouldn't.
>   Fixed.
>  
> How do you parse this? What does it mean?

It’s n-adic COUNT, per DBE (Database-Explorations-revision-2.pdf) pages 129 and 165, and probably others.

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.010 now available!

[Rel a. list. <dba...@li...>]

This release of Rel, an implementation of Date & Darwen's Tutorial D database language, improves the user interface and fixes some bugs.

The following enhancements have been made to the user interface:

- Drop-down menus are now provided for most major operations.

- Double-clicking on a database tree item causes focus to be set to the contents of the tab.

- Double-click now expands/contracts database tree item headings, in addition to the usual keystrokes.

- Variable and View "play" mode shows relation value with improved formatting; "edit" is available from the drop-down and pop-up (right-click) menus.

- The CPU and memory displays in the lower-right corner now follow the typical paradigm of showing resource use, rather than showing resource available.

The following enhancements have been made to the DBMS:

- The storage engine has been updated to Berkeley Java DB version 7.5.11.

- To reduce confusion when copying and pasting code examples that have been auto-corrected, the parser now recognises Unicode asymmetric quotes (‘ ’ “ ”) and generates a human-friendly error.

The following bugs have been fixed:

- fix: DBMS:
  Given:
	COUNT {S WHERE CITY = CITY, S WHERE STATUS = STATUS}
   Result:
   	Returns type mismatch error when it shouldn't.
  Fixed.

- fix: DBMS:
  Given:
	VAR TEST4 REAL RELATION 
		{ID INTEGER, RVA RELATION {RID INTEGER, STR CHAR}} KEY {ID};
	INSERT TEST4 RELATION {
		TUPLE {ID 1, RVA RELATION 
		{TUPLE {RID 11, STR 'A'}, TUPLE {RID 22, STR 'E'}}}
	};
  Execute:
	UPDATE TEST4 WHERE ID = 1: 
	       {UPDATE RVA WHERE RID = 22: {STR := 'blah'}};
	UPDATE TEST4 WHERE ID = 1: 
	       {UPDATE RVA WHERE RID = 22: {STR := 'blah'}};
  Result: TUPLE {RID 22, STR 'blah'} is incorrectly deleted.
  Fixed.
 
- fix: UI: CSS on exported HTML for tabular displays did not correctly format table heading text. Fixed.

- fix: UI: Command-line correctly detects execute vs evaluate by ignoring whitespace and comments.
  
For more information, or to download Rel, go to https://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.009 now available!

[Rel a. list. <dba...@li...>]

This is a minor bug-fix release of Rel, an implementation of Date & Darwen's Tutorial D database language. 

A performance problem has been corrected that caused slow database loading and interaction on some networks.

The Java JRE has been updated to version 8u151.

For more information, or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.008 is now available.

[Rel a. list. <dba...@li...>]

This is a minor bug-fix release of Rel, an implementation of Date & Darwen's Tutorial D database language.
There was a bug in INSERT that caused additional KEY constraints to be ignored. For example, given the following:
VAR myvar REAL RELATION {x INT, y INT} KEY {x} KEY {y};
INSERT myvar REL {TUP {x 1, y 1}};
The following would correctly report 0 tuples inserted:
INSERT myvar REL {TUP {x 2, y 1}};
But would erroneously insert the tuple. This has been corrected.
The Berkeley Java DB library (used to implement the storage engine) has been updated to version 7.4.5, and the bundled Java JRE has been updated to version 8u144.
For more information, or to download Rel, go to http://reldb.org <http://reldb.org/>

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.007 now available.

[Rel a. list. <dba...@li...>]

This is a minor release of Rel, an implementation of Date & Darwen's Tutorial D database language. It adds EQUIV and RANK operators, slightly tweaks the Tutorial D grammar implementation to reduce the need for parentheses, provides infix invocation for certain operators, and fixes some bugs.

The following enhancements have been made to the Rel implementation of Tutorial D:

- Infix syntax for EXTEND, SUMMARIZE and UPDATE expressions is now available. The prefix syntax has been retained, but these are now allowed:

   S EXTEND {SS := STATUS}
   S EXTEND: {SS := STATUS}
   S SUMMARIZE BY {CITY} {SS := SUM(STATUS)}
   S SUMMARIZE BY {CITY}: {SS := SUM(STATUS)}
   S UPDATE {STATUS := 2}
   S UPDATE: {STATUS := 2}

- Dyadic and monadic relational operators now have equal precedence, except WHERE (lower precedence) and projection (higher precedence). This means operators may often be "chained" naturally without requiring parentheses. E.g., S RENAME {CITY AS PLACE} WRAP {PLACE, STATUS} AS T is allowed, where previously (S RENAME {CITY AS PLACE}) WRAP {PLACE, STATUS} AS T would have been required. This should not affect existing code.

- EQUIV has been implemented, per Date & Darwen's "Database Explorations". Both prefix and infix syntax are available:

   RANK S BY (ASC STATUS AS Ranking) 
   S RANK BY (ASC STATUS AS Ranking) 
   S RANK (ASC STATUS AS Ranking)

- RANK has been implemented, per Date & Darwen's "Data Types and the Relational Model".

The following bugs have been fixed:

- Case #139 - #142: In the Rel UI, a fatal error was sometimes inappropriately generated when a query was cancelled in the command-line view. This has been fixed.

- Case #153: Errors in built-in or user-defined Java-based operators now generate an error message rather than causing a fatal error.
  
For more information or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.006 now available!

[Rel a. list. <dba...@li...>]

This is a minor maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language. It makes some improvements to the Rel user interface, now provides a selection of built-in operators that previously had to be loaded from a script, and fixes various minor bugs.

IMPORTANT NOTE: Once opened with this or later versions of Rel, databases cannot be read by earlier versions.

The following enhancements have been made:

- In the Rel DBMS, all operators previously found in the UsefulOperatorsAndViews.rel script are now built-in, and the sys.OperatorsBuiltin relvar provides documentation of built-in relvars via the Definition attribute. In the Rel UI, this can be displayed by double-clicking on an Operator, or by pressing the associated Play button.

- The Rel DBMS's storage engine has been updated to Oracle Berkeley DB JE version 7.3.7

- The Rel DBMS now supports external Rel DBMS relvars. This requires that a standalone Rel DBMS be running on the specified host.  
  E.g.:
     VAR myvar EXTERNAL RELVAR "host,username,password,relvarname"; 
     VAR myvar EXTERNAL RELVAR "host,user,pass,vname,1234"; // port is 1234

- The Rel DBMS now provides built-in QUOTE(CHAR) RETURNS CHAR and UNQUOTE(CHAR) RETURNS CHAR operators to quote/unquote delimiters and special characters.

The following bugs have been fixed:
         
- Rel DBMS: External relvar column name cleanup erroneously turned ‘g' and 'i' to '_'. Fixed.

- Rel DBMS: Extraneous spaces are no longer inserted into EXTERNAL ACCDB and EXTERNAL JDBC relvar definitions.

- Rel DBMS: The UPDATE operator (not statement) allowed duplicate tuples to be emitted. Fixed.

- Rel DBMS: The IN operator sometimes returned an incorrect result if the tuple operand had a different attribute order from the relation operand. Fixed.

- Rel UI: In Rev, single quotes in a RESTRICT, EXTEND, SUMMARIZE or UPDATE expression caused the expression not to be saved. Fixed.

For more information or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.005 now available!

[Rel a. list. <dba...@li...>]

This is a minor maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language. It makes some improvements to the Rel user interface, adds some system relvars, and fixes two bugs.

IMPORTANT NOTE: Once opened with this or later versions of Rel, databases cannot be read by earlier versions.

The following enhancements have been made:

- The Rel user interface's REAL relvar design view has been aesthetically improved -- the command-line display can be hidden or revealed by clicking a button.

- The Rel user interface's REAL relvar design view now prompts the user if an attempt is made to close a tab without first applying pending changes.

- The Rel user interface now provides user-friendly support for creating external relvars via dialog boxes.

- The Rel DBMS provides a sys.ExternalRelvarTypes relvar that documents the available external relvar types.

- The Rel DBMS provides a sys.Keywords relvar that lists all keywords in the Rel / Tutorial D language grammar.

The following bugs have been fixed:

- Case #135: Rel UI: Special characters now work correctly under Windows.

- Case #136: Rel UI: The command-line entry panel is now always in focus after executing code.

For more information or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.004 released!

[Rel a. list. <dba...@li...>]

This is a maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language. It fixes some bugs, and provides some minor enhancements including a faster GROUP operator, the ability to use Unicode character symbols for certain operators, and makes refinements to the Rel user interface.

The following enhancements have been made:

Case #133: The Rel command-line's 'Save' operation's default filename and path is now set to the filename and path of the most recent 'Load file' operation.

!!SP or !!(SP) is now equivalent to IMAGE_IN(SP), and !!(SP, TUP{x 1}) is equivalent to IMAGE_IN(SP, TUP {x 1}). This brings Rel into line with Date & Darwen's "Database Explorations" text.

The following Unicode operator symbols are now supported: 
  ≤ Less than or equal 
  ≥ Greater than or equal 
  ≠ Not equal 
  × Scalar multiplication 
  ÷ Scalar division 
  ‼ Image in (see above) 
  ⊂ Proper subset 
  ⊆ Subset 
  ⊃ Proper superset 
  ⊇ Superset 
  ∈ Is element of (alias for IN)

In the Rel user interface's command-line entry panel (the lower panel of any command-line), a button has been provided to launch a dialog box to facilitate entering the above Unicode operators.

The GROUP operator is now significantly faster, at the expense of somewhat increased memory consumption.

Note: The Unicode support described above has been found to be buggy on (at least) Windows 7 and Windows 10. This will be corrected in a future update. It works correctly on OS X and Linux.

The following bugs have been fixed:

Case #134: In the Rel user interface, the command-line entry panel now consistently focuses on highlighted errors. This makes it possible to immediately type a correction without having to click on the entry panel.

Due to a bug in the GROUP operator, the following produced an incorrect result:

   RELATION {TUPLE {SID 1, PID 1}, TUPLE {SID 4, PID 5}} GROUP {PID}
      AS PARTS UNION RELATION {TUPLE {SID 1, PARTS RELATION {TUPLE
      {PID 1}}}, TUPLE {SID 4, PARTS RELATION {TUPLE {PID 5}}}}

This has been corrected.

In the Rel user interface's visual query language, the "View Query" '?' dialog invoked from any query node no longer crashes after changing mode.

In the Rel user interface, viewing a VIEW or relvar with no attributes no longer crashes.

In the Rel user interface, the 'Zoom in or out' button in the command-line mode is now positioned correctly in its toolbar. Previously, it was positioned too far to the right.

For more information or to download Rel, see https://reldb.org <https://reldb.org/>

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.003 now available.

[Rel a. list. <dba...@li...>]

This is a maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language. The most significant new feature is the ability to connect to external CSV files, XLS and XLSX spreadsheets, Microsoft Access databases, and JDBC database connections, and represent their contents as relation-valued variables (aka relvars). Facilities have also been provided to easily export relvars and query results as CSV and spreadsheet (XLS or XLSX) files.

IMPORTANT NOTE: Once opened with this or later versions of Rel, databases cannot be read by earlier versions.

The following enhancements have been made:
Support for UNORDER() (the inverse of ORDER(), to convert an ARRAY to a RELATION) has been added to the visual query editor in the Rel user interface.
In the Rel user interface, a "refresh" toolbar item has been added to VIEWs, the same as for VARiables.
In the Rel user interface, the visual query editor's "View Query" '?' dialog now provides option to emit query text, or VIEW and OPERATOR definitions, directly to command-line. Furthermore, the dialog box is no longer modal; makes it easier to use query definition elsewhere.
In the Rel user interface's command-line, the initial use of the Save dialog defaults to directory of the most recent Load, if Load used first. Likewise, the initial Load dialog defaults to directory of most recent Save, if Save is used first.
In the Rel user interface, Variables (relvars), Views, and visual query results may now be exported to CSV text files and XLS/XLSX spreadsheet files.
In the standalone Rel DBMS, all application .jars have been moved to the /lib subdirectory.
Support for accessing CSV files, XLS/XLSX spreadsheet files, Microsoft Access databases, and JDBC databases for various popular DBMSs, and representing their contents as relation-valued variables (relvars) is now built-in. See https://reldb.org/c/index.php/read/accessing-external-data-sources/ <https://reldb.org/c/index.php/read/accessing-external-data-sources/> for further information.
The following bugs have been fixed:
In the Rel user interface, spaces in application path caused external Java-based operator compilation to fail. Fixed.
In the Rel user interface, the "Get File Path" button now correctly returns backslashes in file path as '\\'.
In the Rel user interface, failing to open a database could allow all database tabs to be closed, which left the Rel UI in an unstable state. Fixed.
For more information, or to download Rel, go to https://reldb.org <https://reldb.org/>

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.002 now available for download

[Rel a. list. <dba...@li...>]

This is a minor maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language.

The following enhancements have been made:

The Rel user interface can now load a specified database from the operating system command-line. E.g.: Rel "c:\Users\Dave\My Database”

The Rel user interface now provides an option to specify that the user's default database should not be automatically displayed in a tab when the Rel user interface is launched. See Preferences | General | Do not automatically load user's default database.

The following bugs have been fixed:

If the database path contained spaces, it would cause Java-based operators to fail to compile when being defined. This has been fixed.

Opening a new database tab would sometimes hide the mode (Rel/Rev/Cmd) buttons. This has been fixed.

Under Windows, double-clicking on an *.rdb or *.rel file in the file explorer failed to start up Rel and load the specified database or file despite specifying appropriate file associations. This has been fixed. Note that file associations must be set via the operating system.

For more information, or to download Rel, go to http://reldb.org <http://reldb.org/>

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.001 now available for download

[Rel a. list. <dba...@li...>]

This is a minor maintenance release of Rel, an implementation of Date & Darwen's Tutorial D database language.

The following enhancements have been made:
A startup progress bar displays whilst the Rel user interface is loading. On slow machines, this makes it clear that loading is progressing and not stuck.
More detailed crash reporting has been implemented, to help the development team find and fix bugs.
An ATTRIBUTES_OF(r) pseudo-operator has been provided. It may be used anywhere a comma-separated list of attributes can appear. E.g., WITH (t := TUPLE {STATUS 20}): (S JOIN RELATION {t}) {ATTRIBUTES_OF(t)} or WITH (t := TUPLE {STATUS 20}): (S JOIN RELATION {t}) {ALL BUT ATTRIBUTES_OF(t)}
The following bugs have been fixed:
In the Rel user interface, a crash occurred in Windows when showing row/tuple delete confirmation. This has been fixed.
Case #94: org.reldb.rel.v0.languages.tutoriald.parser.TokenMgrError should have been ExceptionSemantic, not ExceptionFatal.
Case #113 - #118: A crash in the Rel UI when editing a relvar with no attributes has been fixed.
Case ID #119: VAR test BASE RELATION {x INTEGER, y INTEGER} INIT (TUPLE {x 10, y 20}) KEY {}; threw a fatal exception that should have been a semantic exception. This has been fixed.
For more information or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 3.000 now available for download

[Rel a. list. <dba...@li...>]

This is a major release of Rel, an implementation of Date & Darwen's Tutorial D database language. It introduces a new graphical "front end" user interface that provides rich desktop database management functionality and a native look-and-feel on Windows, Mac OS X, and Linux. It is the starting point for what will be a significant focus on friendly, end-user oriented functionality in forthcoming releases.

As part of this release, the version numbering system has changed. The entire Rel release, including the standalone DBMS and the user-interface, is version 3.000. The standalone DBMS carries on the Rel version numbering from before; the last release was version 1.0.12 so the standalone DBMS is now version 1.0.13.

Rel now runs under Java 8. Running a standalone Rel DBMS requires that it be installed, but a typical Rel distribution including the user interface bundles a Java runtime, so it's usually not necessary to download Java separately.

The source code is now available on GitHub under https://github.com/DaveVoorhis/Rel and is easily loaded into the Eclipse IDE to facilitate further development.

Major features of the new user interface include:

1. Displaying, editing, and designing relation-valued variables, operators, constraints, types, queries (expressions), and other database objects can now be done via a graphical interface, in addition to the traditional command-line.

2. Code entry is now enhanced with syntax highlighting, find/replace, undo/redo, persistent edit history, and "zoom" buttons to maximize the input or output display. Rel scripts may be saved in and retrieved from the database.

3. A graphical query language called Rev, based on a data-flow metaphor, is fully integrated and generates Tutorial D / Rel code.

4. The backup facility is now fully integrated. Database backups can be made at the click of a button and do not rely on an external script.

5. The default database is created in the user's home directory, rather than inside the Rel program folder or directory. Other databases can be easily loaded from the user interface and multiple local and remote databases can be used simultaneously.

Significant enhancements have also been made to the Rel implementation of the Tutorial D database language:

1. TUPLE {*} now returns the "current tuple" in any open expression. TUPLE {*} is equivalent to ​​PLE {A1 A1, ..., AAn}, where A1, ..., An are the attributes of an implied relation such as the relation operand to an invocation of WHERE or EXTEND.  The keyword TUPLE can be abbreviated to TUP, as in other places where it appears in the language.

2. IMAGE_IN(r, t) where r is a relation and t is a tuple, is equivalent to (r JOIN RELATION {t}) {ALL BUT A1, ..., An}, where A1, ..., An are the attributes of t. The tuple operand to IMAGE_IN may be omitted, defaulting to TUPLE {*}. Thus, IMAGE_IN(r) is equivalent to !!r as proposed in Date & Darwen's Database Explorations, Chapter 14.

3. ARRAY TUPLE {...} is now a valid parameter type.

4. User-defined aggregate operators are now supported, as described in http://reldb.org/c/wp-content/uploads/2016/06/User-Defined-Aggregate-Operators-in-Tutorial-D-and-Rel.pdf

5. Altering relvar definitions is now supported via: 
	ALTER VAR <relvar> TYPE_OF <attrname> TO <newattrtype> 
	ALTER VAR <relvar> RENAME <oldattrname> AS <newattrname> 
	ALTER VAR <relvar> INSERT <newattrname> <newattrtype> 
	ALTER VAR <relvar> DROP <attrname> 
	ALTER VAR <relvar> KEY {<keyspec>} [... KEY {<keyspec>}] (must be last)

6. All data definition statements are now logged in sys.DefinitionHistory.

7. SET_UNIQUE_NUMBER(INT) built-in operator has been provided and is used in the DatabaseToScript.rel script.

8. IF, CASE, DO, WHILE, FOR and OPERATOR definitions now support multiple statements without requiring BEGIN .. END blocks.

9. Keywords IF, CASE, DO, WHILE, FOR and OPERATOR are now optional after the END that closes a block.

10. POSSREP component definitions may now be surrounded with "( ... )" (preferred) or "{ ... }" (deprecated).

11. Updated storage engine to Oracle Berkeley DB JE version 7.0.6

12. External Java compilation is now fully integrated; a JDK is no longer required.

13. System startup announcement now provides more information about the runtime platform.

14. Removed octal and hex integer representations, as these were a source of confusion.

15. Empty EXTEND, e.g., EXTEND S: {}, is now permitted.

16. Empty UPDATE, e.g., UPDATE S: {}, is now permitted.

17. Added a sequence generator built-in operator: OPERATOR SEQUENCE(first INT, last INT, step INT) RELATION {n INT}; OPERATOR SEQUENCE(first INT, last INT) RELATION {n INT};

18. TYPE_OF(e) pseudo-operator returns type metadata about any expression using new built-in types TypeInfo, Scalar and NonScalar.

19. The sys.Catalog relvar now provides Attributes and Keys metadata.

20. Relvar update notices can be turned off with SET VerboseRelvarUpdates Off.

21. All relations are now emitted with their heading. This improves readability & parse-ability.

22. A modulo operator (%) is now built-in. E.g., 3 % 4 is a valid expression.

23. A bug has been fixed: UNION (RELATION {x RELATION {y INT}} {}, x) returned an error. It should have returned RELATION {y INT}} {}. The same applies to D_UNION and XUNION. This has been corrected.

For more information or to download Rel, go to http://reldb.org

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.12 now available!

[Rel a. list. <dba...@li...>]

This version of /Rel/ -- an implementation of Date & Darwen's *Tutorial 
D* database language -- is a maintenance release featuring some 
enhancements and bug fixes.

Changes in this update:

* Enhancement: Rel: Updated storage engine to Oracle Berkeley DB Java 
Edition version 6.2.7.

* Enhancement: Rel: Database resilience after power failures or system 
crashes has been considerably improved.  In the majority of power 
failures or system crashes, it should be possible to load /Rel/ and 
resume use without errors or data loss.

* Fix: Rel: Updates to relation-valued parameters, which created 
side-effects, have been disallowed.

* Fix: Rel: TREAT_AS_type() and IS_type() did not work correctly with 
static inheritance.  This has been corrected.

* Fix: Rel: The following caused Rel crashes due to a "hash error" on 
Temperature_NoReading(), etc. This has been corrected.
        TYPE Temperature UNION;
        TYPE Temperature_Normal IS {Temperature POSSREP {t INTEGER}};
        TYPE Temperature_NoReading IS {Temperature POSSREP {}};
        TYPE Temperature_OutOfRange IS {Temperature POSSREP {}};
        VAR Readings REAL RELATION {timestamp INTEGER,
                               temp Temperature} KEY {timestamp};
        INSERT Readings REL {
         TUP {timestamp 12938, temp Temperature_Normal(33)},
           TUP {timestamp 12940, temp Temperature_Normal(33)},
           TUP {timestamp 12943, temp Temperature_Normal(34)},
           TUP {timestamp 12948, temp Temperature_NoReading()},
           TUP {timestamp 12955, temp Temperature_OutOfRange()}
        };

* Fix: Rel: Some CONSTRAINT failures displayed an un-helpful 
"Transaction is not active" error message instead of identifying the 
failing constraint.  This has been corrected.

For more information, or to download Rel, see 
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.11 Released!

[Rel a. list. <dba...@li...>]

This version of /Rel/--- an implementation of Date & Darwen's *Tutorial 
D* database language--- is a maintenance release featuring various 
enhancements and bug fixes.

Prior to installing this version of /Rel/, you must make a backup of 
your database(s). Then, install this update and load and attempt to 
execute your backup script(s). If your script successfully loads, you're 
done. If /Rel/ complains of syntax errors, you'll need to edit the 
backup script --- based on the "/Rel/ Version 1.0.11+ Syntax" article at 
http://dbappbuilder.sourceforge.net --- until the script successfully loads.

Changes in this update:

* Enhancement: DBrowser: Now displays human-friendly messages when 
attempting to open an already-open database, or when a connection 
attempt to a remote /Rel/ server fails.

* Enhancement: DBrowser: Now provides options to hide headings and 
declared types in headings in displayed output of relations.

* Enhancement: DBrowser: Now provides a "Get File Path" button to 
simplify putting file paths in source code.  This facilitates use of 
external data sources, described below.

* Enhancement: Rel: Some minor syntax improvements have been made, in 
accordance with changes to *Tutorial D*. Formerly-required parentheses 
around WRAP, UNWRAP, GROUP, UNGROUP clauses have been removed. UNGROUP 
(a) and UNWRAP (a) are now UNGROUP a and UNWRAP a, respectively.

* Enhancement: Rel: All error messages are now uniquely identified to 
disambiguate references to them.

* Enhancement: Rel: Updated to version 6.0.11 of the Berkeley Java DB, 
which is used as a storage engine.

* Enhancement: Rel: A student project has produced simple support for 
external CSV/XLS/XLSX/JDBC sources as relvars:

  e.g., VAR myvar EXTERNAL CSV "/home/dave/test.csv";
  e.g., VAR myvar EXTERNAL XLS "/home/dave/test.xls" DUP_REMOVE;
  e.g., VAR myvar EXTERNAL XLS "/home/dave/test.xlsx" DUP_COUNT;
  e.g., VAR myvar EXTERNAL XLS "/home/dave/test.xlsx" AUTOKEY;
  e.g., VAR myvar EXTERNAL JDBC 
"<host>,<user>,<password>,<database>.<table>,<driverpath>,<drivername>";

This feature also makes it possible to define new relvar types as /Rel/ 
plug-ins.  Documentation for this feature will be provided in the future.

* Enhancement: Rel: 'x RENAME {}' is now valid syntax.

* Enhancement: Rel: Errors occurring in a database constraint are now 
treated as if the constraint evaluates to false, and the failing 
constraint is named in the error message.

* Fix: DBrowser: Fixed minor errors parsing certain error messages.

* Fix: Rel: Given...

    VAR S BASE RELATION {
         SNO CHAR, SNAME CHAR, STATUS INTEGER, CITY CHAR
    } KEY {SNO};
    VAR SP BASE RELATION { SNO CHAR, PNO CHAR, QTY INTEGER } KEY {SNO, PNO};
    VAR SPQ BASE INIT(
       EXTEND S: {PQ := RELATION {TUPLE {SNO SNO}} COMPOSE SP}
    ) KEY{SNO};

...these failed:

   UPDATE SPQ WHERE SNO = "S2":
       {INSERT PQ RELATION {TUPLE {PNO "P5", QTY 500}}};
   UPDATE SPQ WHERE SNO = "S2": {UPDATE PQ WHERE PNO="P5": {QTY := 250}};
   UPDATE SPQ WHERE SNO = "S2": {DELETE PQ WHERE PNO="P5"};

This has been corrected.

* Fix: Rel: The following should have returned true but returned false:

      RELATION  {
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P5"}
             }},
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P2"}
             }},
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P4"}
             }}
      }
      =
      RELATION  {
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P5"}
             }},
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P2"}
             }},
             TUPLE { SUPPLIES RELATION {
               TUPLE {PID "P4"}
             }}
      }

This has been corrected.  Internal changes to address this and similar 
errors in comparing relations with relation-valued attributes may have 
performance impact -- some queries may run faster, others slower.

* Fix: Rel: JOIN {}, TIMES {}, and COMPOSE {} now return DEE.

* Fix: Rel: XUNION {}, D_UNION {}, UNION {} now return TUPLE {}.

* Fix: Rel: XUNION {} {}, D_UNION {} {}, UNION {} {} return DUM.

* Fix: Rel: INTERSECT {} and INTERSECT {} {} throw an error.

* Fix: Rel: Type checking was too weak on comparison operators, allowing 
incorrect expressions like 'tuple{x 1} = tuple{y 2, x 1}' to return a 
result instead of throwing an error.  Fixed.

* Fix: Rel: RELATION {TUPLE {x 10, y DEE}} WHERE x = 100 UNGROUP y threw 
a fatal error.  It should have thrown a type error due to an attempt to 
ungroup integer 100. This has been fixed.

* Fix: Rel: Built-in operator name OP_GREATHERTHANOREQUALS corrected to 
OP_GREATERTHANOREQUALS.

* Fix: Rel: Assignment to a real relvar altered its CreationSequence. Fixed.

* Fix: Rel: CAST_AS_INTEGER("blah") and CAST_AS_RATIONAL("blah") should 
have thrown semantic errors, not fatal errors.  Fixed.

Note: This release includes experimental support for a work-in-progress 
visual query language called Rev. Using an icons-on-strings data-flow 
style, it permits constructing queries visually and iteratively, and 
allows testing sub-expressions whilst constructing a query. To 
experiment with it, install the Rev package and it will appear as an 
additional tab in a DBrowser session. To remove it, delete the rev.jar 
file. Further documentation and video demonstrations will be provided in 
the future.

For more information, or to download /Rel/, see 
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.10 Beta now available

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial
D" database language -- is a significant release, as it implements the
latest Tutorial D syntax from Date and Darwen's book "Database
Explorations: Essays on The Third Manifesto and related topics" (ISBN
978-1426937231)

Prior to installing this version of Rel, you must make a backup of
your database(s). Then, install this update and load and attempt to
execute your backup script(s). If your script successfully loads,
you're done. If Rel complains of syntax errors, you'll need to edit
the backup script — based on the "Rel Version 1.0.10+ Syntax" article
at http://dbappbuilder.sourceforge.net — until the script successfully
loads.

Changes in this update:

  - Fix: Rel: Revised execution order of statements in multiple
    assignment to prevent counterintuitive behaviour. Assignments now
    execute from first to last.

  - Fix: Rel: Passing a non-boolean to the WHERE clause of an UPDATE
    would result in a crash.  Fixed.

  - Enhancement: Rel: Added partial support for anonymous operators.
    This is a work-in-progress documented at   
http://dbappbuilder.sourceforge.net/docs/AnonymousAndFirstClassOperatorsInTutorialD.pdf

  - Enhancement: Rel: Updated to version 5.0.58 of Berkeley Java DB,
    which is used as the storage engine.

  - Enhancement: Rel: Various changes to support Tutorial D syntax from
    Database Explorations:

    EXTEND:
       old: EXTEND r ADD (p AS q, a AS b)
       new: EXTEND r : {q := p, b := a}
    UPDATE:
       old: UPDATE r (p := q, b := a)
       new: UPDATE r : {p := q, b := a}
    RENAME:
       old: r RENAME (a AS b)
       new: r RENAME {a AS b}
    SUMMARIZE:
       old: SUMMARIZE p ADD (SUM(x) AS y)
       new: SUMMARIZE p : {y := SUM(x))
    WITH:
       old: WITH a AS b, x AS y : ...
       new: WITH (b := a, y := x) : ...
    WRAP:
       old: r WRAP ({a, b} AS c, {d, e} AS f)
       new  (r WRAP ({a, b} AS c)) WRAP ({d, e} AS f)
    UNWRAP:
       old: r UNWRAP (a, b)
       new: (r UNWRAP (a)) UNWRAP (b)
    GROUP:
       old: r GROUP ({a, b} AS c, {d, e} AS f)
       new  (r GROUP ({a, b} AS c)) GROUP ({d, e} AS f)
    UNGROUP:
       old: r UNGROUP (a, b)
       new: (r UNGROUP (a)) UNGROUP (b)
    Removed ANY and ALL synonyms for OR and AND.
    Implemented n-adic COMPOSE.
    Implemented XUNION, TIMES, I_MINUS, I_DELETE,
       D_INSERT and updated INSERT to silently
       ignore duplicate tuples.

  - Fix: Rel tests: revised TestDelete0 and TestRelvar26 to eliminate
    order-dependent testing.

  - Enhancement: Rel: POSSREP keyword ORDERED now recognised in
    addition to ORDINAL, but is a no-op.

  - Enhancement: Rel: Improved shutdown procedure is less likely to
    result in a corrupt database if there are problems encountered
    during shutdown.

  - Enhancement: Scripts: DatabaseToScript.d, Views.d changed to
    accommodate support for Database Explorations syntax.

  - Enhancement: DBrowser: Splash screen disappears as soon as Ok
    appears.

  - Enhancement: DBrowser: Error messages that specify line and column
    now cause the cursor to move to the position of the error in the
    source.

For more information, or to download Rel, see
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.9 Beta released

[Rel a. list. <dba...@li...>]

This version of /Rel/ -- an implementation of Date & Darwen's *Tutorial 
D* database language -- is a maintenance release featuring various 
enhancements and bug fixes:

- Fix: Unicode support is now explicitly provided in /Rel/, DBrowser,
   and the RelClient middleware.  This should reduce the likelihood of
   errors or incorrect character translations when inputting unicode
   characters.

- Fix: /Rel/: A problem emitting escaped characters (special characters
   prefixed with a backslash, e.g., '\t') has been corrected, so that
   (for example) repeatedly backed up and restored Rel databases will
   no longer exhibit a harmless but awkward repetition of backslashes
   in certain string values.  E.g., names like "O\\\\\\\\\\\\\\'Neil"
   should no longer occur.

- Fix: /Rel/: Replaced reference to
   "ca.mb.armchair.rel3.values.ValueChar" with
   "ca.mb.armchair.rel3.values.ValueCharacter" in
   ForeignCompilerJava.java.  This fixes problems creating new
   Java-based types which define methods/operators that use CHAR
   parameters.

- Enhancement/Fix: RelTest: Test suite has been redesigned to support
   execution of tests in random order.

- Enhancement/Fix: /Rel/: Updated to version 5.0.34 of Berkeley Java DB.
   As a side-effect of implementing this, occasional database
   corruptions leading to crashes -- typically referring to duplicate
   btree keys and the like -- should no longer occur.

- Enhancement: /Rel/: Temporary internal buffering of relations now
   dynamically switches from in-memory to disk-based storage based on
   cardinality.  This will improve performance on low-cardinality
   queries whilst supporting very high cardinality queries.

- Enhancement: /Rel/: Implemented mechanism to ensure expected version
   of Berkeley Java DB is installed.  This eliminates possible errors
   due to running an incompatible version of the Berkeley Java DB.

- Enhancement: Scripts: TypeDate.d now implements THE_readable, which
   obtains a human-friendly date.

- Enhancement: /Rel/: Improved speed of compiling Java-based types and
   operators.

- Enhancement: DBrowser: Crashes will now automatically open a dialog
   box to allow the user to send an error report to the developers.

For more information, or to download /Rel/, see 
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.8 Beta released

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial D" 
database language -- is a maintenance release featuring one enhancement 
and two bug fixes:

1. Enhancement: Rel: Error reporting has been improved when Java-based
    built-in operators fail.  E.g., SUBSTRING("blah", 1, 20) used to fail
    in an un-helpful manner. Now, the error message goes some way toward
    explaining and locating the problem.

2. Fix: Rel: The following failed with a low-level error; now fixed:

     var items private relation { id  integer, name  character } init (
      relation {
       tuple {id 1, name "hi"},
       tuple {id 2, name "lo"},
       tuple {id 3, name "do"}}) key {id};
     var result private relation {r relation same_heading_as(items)} key 
{r};
     var inner private relation same_heading_as(items) key {id};
     insert inner relation {tuple from items where id = 1};
     insert result relation {tuple {r inner}};

3. Fix: Rel: Updating a relation-valued attribute, as in the following...

     var x private relation {a integer, b relation {c integer}}
          init (relation {tuple {a 1, b relation {tuple {c 2}}}})
          key {a};
     update x where a = 1 (b := update (b) (c := 33));

    ...caused an error like the following:
    "ERROR: '%tuple23' has not been defined."
    This has been corrected.

For more information, or to download Rel, see 
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.7 Beta released

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial D"
database language -- is a minor release featuring the following fixes and
enhancements:

1. Enhancement: New built-in operator GET_UNIQUE_NUMBER returns an integer
guaranteed to be unique in a given database.

2. Fix: Given TYPE POSINT IS {INTEGER CONSTRAINT INTEGER > 0},
MAX(RELATION {TUPLE {X 1}, TUPLE {X 2}}, X) failed due to a missing
target.  Fixed.

3. Fix: A longer default transaction timeout has been set, to reduce the
likelihood of spurious timeouts in multithreaded client applications.

4. Fix: A number of bugs that prevented PRIVATE RELATION from working
correctly have been fixed.

For more information, or to download Rel, see
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.6 Beta released

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial D"
database language -- is a minor release featuring two enhancements:

1. Previously, aggregate operator invocations like the following...

   SUM(sys.Catalog, CreationSequence)

   ...could only reference an attribute.  The following would not work:

   SUM(sys.Catalog, CreationSequence + 1)

   In this release, aggregate operator invocations may specify an
   expression.  Both of the above expressions will now work.

   This change is in accordance with the Tutorial D specification 
   found in Date & Darwen's "Database Explorations - Essays on 
   the Third Manifesto and Related Topics".

2. Short synonyms are now available for some common keywords.  
   RELATION may be specified as REL, TUPLE as TUP, INTEGER as 
   INT, RATIONAL as RAT, and BOOLEAN as BOOL.  This is also in
   accordance with "Database Explorations ..."

   Note that DEE and DUM have always been available as synonyms for 
   TABLE_DEE and TABLE_DUM, respectively.

For more information, or to download Rel, see
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.5 Beta released

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial D"
database language -- is a maintenance release featuring two bug fixes:

1. A bug in the way relation literals were parsed allowed the
following...

	RELATION {x INTEGER, y INTEGER} {
		TUPLE {x 1, z 1}
	}

   ...to be accepted and yield:

	RELATION {x INTEGER, y INTEGER} 
		{TUPLE {x 1, y 1}
	}

   This has been corrected.

2. Due to a change in the way the third-party storage engine (Oracle
Berkeley Java DB) generated exceptions -- introduced in Java DB version
4.0.71 -- Rel did not correctly handle an exception related to
transactions and could wind up throwing its own internal exceptions.
This was especially likely when attempting to drop a constraint or
relvar immediately after a Rel error message had been generated.  This
has been corrected.

For more information, or to download Rel, see
http://dbappbuilder.sourceforge.net/Rel.html

[Dbappbuilder-relannounce] ANNOUNCE: Rel version 1.0.4 Beta released

[Rel a. list. <dba...@li...>]

This version of Rel -- an implementation of Date & Darwen's "Tutorial D"
database language -- provides two enhancements and several bug fixes.

Enhancements:

1. Inference of most specific common supertype (excluding Alpha) has
been implemented, such that evaluating...

  RELATION {
    TUPLE {x Triangle(Point(0,0), Point(2,3), Point(7,4))}
    TUPLE {x Square(Point(1,1), Point(4,3))}
  }

...returns...

  RELATION {x Shape} {
    TUPLE {x Triangle(Point(0,0), Point(2,3), Point(7,4))}
    TUPLE {x Square(Point(1,1), Point(4,3))}
  }

...assuming the existence of types 'Triangle' and 'Square' which are
subtypes of 'Shape'.

2. Selectors are now generated for immediate subtypes of built-in types,
as per Date & Darwen's "Database Explorations" (ISBN 978-1-4269-3723-1),
Chapter 21, page 348 "Selectors for System Defined Types".  E.g., the
following...

  TYPE PosInt IS {INTEGER CONSTRAINT INTEGER >= 0};

...will automatically create a selector called PosInt which accepts an
INTEGER as its sole argument and returns a PosInt value.

Bug Fixes:

1. A derived POSSREP definition list should be allowed to be empty when
defining a type whose immediate supertype is a built-in type.  However,
Rel previously required at least one POSSREP.  E.g., the following
legitimate definition was not allowed:

  TYPE PosInt IS {INTEGER CONSTRAINT INTEGER >= 0};

This has been fixed.

2. A bug has been corrected that could, in rare circumstances, cause a
database to fail to open due to an internal "LOG INTEGRITY" error.

3. A bug has been corrected that could, in rare circumstances, cause
corruption of user-defined type values when inserted into a relvar
immediately after any Rel error (e.g., a syntax error) has been
generated. 

For more information, or to download Rel, see
http://dbappbuilder.sourceforge.net/Rel.html