The Database Extreme Library is a share library for PDA Toolbox applications.  It provides database manipulation actions.

This library provides higher level actions for database manipulations including advanced filtering, copying, deleting, and exporting records, and calculating fields.  There are two primary techniques for advanced filtering: Advanced "In-Place" and "Keyset" filtering.  In-place filters are essentially what PDA Toolbox already provides, however, it is limited to one criteria field which is generally a popup filtering a table.  Using the .Select action, you can flag and filter records based on nearly any criteria.  Keysets are new databases that contain a subset of records from a "master" database and a unique key field.  Keyset databases may be edited and the master database updated.  

There are several other actions that include clearing fields, deleting records, and exporting to doc files on a database-wide basis.  You can also calculate both string, numeric, and date fields with the .Set actions.  There are over 40 operators and functions supporting the expression and criteria evaluator.

It is also used as a "Plug-In" to PDAT/Advanced to provide additional Actions to your PDA Toolbox programs.  

This manual assumes the reader has familiarity with the PDAT/Advanced application.

The Database Extreme Library is a Shareware Library for the Palm OS® 3.1 and above unless noted (e.g. FmtDate() function).  The distribution module requires 40k of storage memory.  For more information click here.

For PDA Toolbox 6.0 Professional

• The Windows plug-in PDATDBXLib.dll must be copied into the PDA Toolbox folder.
• In the Script Editor, browse for the library from Tools/Options/Libraries dialog.
• Enter your license information when requested, or leave blank to run in trial mode.
• Detailed documentation is included with the Windows plug-in available at www.SandsUSA.com/PDAT.

For PDAT/Advanced Only

Before you can use the actions contained in this library, you must first "plug" it into PDAT/Advanced.  Once plugged in and registered, you will be able to use and distribute this library freely.

1. First, you must have a copy of PDAT/Advanced Version 5.1.2 or greater installed on your development handheld or emulator (recommended).
2. Install the "PDATDBXLib.prc" library file.
3. Install the "PDATDBXSym.pdb" symbol database.
4. At PDAT/Advanced's Open Screen, tap the menu and choose from the Advanced menu "Manage Libraries".
5. Next, if the "Database Extreme Library" is not shown in the list, tap the "Add" button.
6. In the "Add Library" dialog, enter in the Library ID of "DBex" (without the quotes).
7. Next, enter the license information you received when you registered or press OK to use in "trial" mode.
8. Lastly, tap the "Done" button.

After successful registration, when you are editing actions, you'll have a second button named "Lib" which pops up a list of all the commands available to you.

It is recommended that you distribute the runtime version of the library.  This is the "PDATDBXLibRT.prc" file.  This file is smaller than the development library as it does not include any of the code for compiling your application.

Since you are distributing multiple PRC files that must be installed on the hand-held device, you may want to check out Ecamm's NutShell for the Palm OS at http://www.ecamm.com/palm/nutshell.  Nutshell is a unique installer solution, which allows users distribute multiple Palm files and data as a single self-expanding PRC file.  With this tool, the user installs a single file onto their hand-held and the first time your app is run, all the libraries, databases, and sub-programs are automatically unpacked and your app runs.  A very good solution to a sticky problem.

There are two primary techniques for filtering using the Database Extreme Library: In-place and Keysets.  In-place filters are essentially what PDA Toolbox already provides, however, it is limited to one criteria field which is generally a popup filtering a table.  Using the .Select action, you can flag and filter records based on nearly any criteria.  Keysets are new databases that contain a subset of records from a "master" database and a unique key field.  Keyset databases may be edited and the master database updated.  

I've provided two working demos which you can load onto your emulator: Animals1 and Animals2.  Animals1 demonstrates in-place filtering, and Animals2 demonstrates keyset filters.  See the release notes with those two applications for details about databases, etc.

In-Place Filtering - ANIMALS1

The goal of this demo is to demonstrate advanced queries on the primary database using the SELECT action of the Database Extreme Library. Basically, there are two primary databases: The DATA and QURY. You go to the button (Query Animals) and choose the type, # of legs, and skin and tap (Do It!) to perform the query. The records that match will be check-boxed.

The core selection routine is this:

Script 1307 (Do It!) Button
db.Select pets, DATA, CHCK, "mat(DFld({pets}, {QURY}, 0, {LEGS}), 'All', [LEGS]) AND _
	mat(DFld({pets}, {QURY}, 0, {SKIN}), 'All', [SKIN]) AND _
	mat(DFld({pets}, {QURY}, 0, {CATA}), 'All', [CATA])"
GotoForm 1000

The db.Select will scan the database specified in (pets/DATA) selecting all records that match the criteria (last parameter). The CHCK is the field that recieves the selection status. The criteria is a logical expression that says if the LEGS, SKIN, and CATA fields match the user's query request, then it's selected.

The MAT() function is a matching routine. The first parameter is matched to the rest and if found, returns true. For example, MAT('B', 'A', 'B', 'C') would match 'B' to 'A', 'B', or 'C' and return true since 'B' is in the list.

The DFLD() allows you to access another table's value. This function requires the CreatorID, TypeID, Record Number, and Field to retrieve. The record number will almost always be 0 (first record). 

A word about brackets: A field in the current record is bracketed by [ ] as in [LEGS] - this says "get the value of LEGS and use it" whereas the { } brackets are used to postpone getting the values like "get the field ID itself - not the value". So, the DFLD() method typically uses {LEGS} since you don't want to get the VALUE of LEGS - you want to pass the ID of LEGS. In the MAT() routine, you want to pass the actual value of LEGS so it's bracketed like [LEGS]. Confusing, but it will be clear as you see more examples.

Note that in this script, the expressions can have carriage returns and spaces for clarity (unlike SMBeta). This REALLY helps.

Keyset Filtering - ANIMALS2

Keyset filtering is more complicated because you have to create a temporary database, use it, and then update the master with any potential changes you've made.  There are two primary scripts here:

Script 1307 (Do It!) Button
db.KeySet pets, DATA, pets, DAT1,"Animals Data1", "KEY#", " _
    mat(DFLD({pets}, {QURY}, 0, {LEGS}), 'All', [LEGS]) AND _
    mat(DFLD({pets}, {QURY}, 0, {SKIN}), 'All', [SKIN]) AND _
    mat(DFLD({pets}, {QURY}, 0, {CATA}), 'All', [CATA])" 
db.Use pets, DAT1, "Animals Data1", 1000, 1001
db.Use pets, DAT1, "Animals Data1", 1100, 0
GotoForm 1000

Script 1308 (All Animals) Button
db.KeySet.Update pets, DATA, pets, DAT1, "KEY#"
db.Use pets, DATA, "Animals Data", 1000, 1001
db.Use pets, DATA, "Animals Data", 1100, 0
GotoForm 1000

In script 1307, a KeySet is created with the db.KeySet action. A KeySet is a database that contains a copy of all the selected records from the a main database. It contains link field (Key Set Field) that identifies the record back to the main database. This allows you to update the main database by locating each of the original records and updating them from the KeySet record. 

In this case, the KeySet is created from querying the "Animals Data" (pets,DATA), and any records that match are written into "Animals Data1" (pets,DAT1). In addition, a new field is added, "KEY#", that is the KeySet link field.

The two db.Use actions make the KeySet database specified (pets, DAT1, "Animals Data1") the database that is used by a form and optionally, a table. The first USE changes the main form and table (Form 1000, Table 1001). The second db.Use makes the animal editor to use the KeySet database.

For Script 1308, the goal is to select all animals and update the main database from the KeySet database so any changes get saved. This uses the db.KeySet.Update action which basically reads "Update (pets,DATA) from (pets,DAT1) where KEY#=RecordID".

With DBX version 1.25, you now have the ability to use a Stash File.  A stash file is a single-record database that stores misc. data for your use.  In a way, it simulates "global" variables.  It can also be used as a more effective clipboard.  While many developers have been creating their own "home-brewed" version of this feature, the DBX stash file is better: 

• It allows stashing multiple fields at a time instead of using multiple db.Set.Rec actions
• It is more efficient to get the database back using the Stash( ) function rather than the DFLD( ) action which opens/closes the database with every call.
• Unlike the clipboard, it can save data types other than just text.
• It formalizes a technique making it easier to learn and easier to teach others.

To delete a stash file, you use the normal delete actions in PDAT.  To clear all or individual fields from the stash file, you can use the db.Stash.Clear action.

Stash Files are only available with PDA Toolbox 6.0 SP6 or higher.

Each Action in the library will be described here.

Specifying Databases

Since databases can be dynamically changed, there needs to be a "portable" way of specifying the database when an action requires it. For any parameters named CID (creator ID) or TID (type ID) or Filename you can use these two forms:

• Use (CreatorID, TypeID) as normal if you are specifying an exact database.
• Use ("Frm", FormID) if you want to use the definition as specified in FormID.

Among other things, this action is useful for debugging your scripts. If you are having problems with a big expression, use this action to display portions of the expression to ensure that your expressions are returning what you think they are.  This will usually show you where your problem is.

You may use the current open record's fields.  This action may be used with or without an open database.  The alert's caption is always "Information."

This will display an alert that you define in your Professional script with data evaluated from the expression.  Among other things, this action is useful for debugging your scripts. If you are having problems with a big expression, use this action to display portions of the expression to ensure that your expressions are returning what you think they are.  

When it returns, it will branch to the n^th line after the db.Alert.Custom: The first button tapped goes to the following line, the second button tapped goes to the 2^nd line following, the third goes to the third line, etc.  The following example displays a custom alert with three buttons:

Action btnTest
   db.Alert.Custom TestAlert, "LNAM & ', ' & FNAM"
   Goto +3
   Goto +4
   Goto +5
   au.Alert.Custom ResultAlert, "You tapped OK"
   Goto +2 
   au.ALert.Custom ResultAlert, "You tapped Maybe"
   Goto +2
   au.ALert.Custom ResultAlert, "You tapped Cancel"
EndAction

To properly create the alert so that it accepts the text passed to it, you must include in the text the placeholder "^1" as in "Do you want to ^1" where the ^1 is replaced with the text in the db.Alert.Custom action.

You may pass "" if you do not require text to be inserted into the alert.

You may use the current open record's fields.  This action may be used with or without an open database.

Writes records from (sCID,sTID) to (dCID,dTID,dFName) that match the criteria.  This action will create the database if it does not exist.  This supports appending an empty (new) record.  New records are placed at the end of the database and you are responsible for resorting the database if required.

Writes the current record to (CID,TID,FName).  This action will create the database if it does not exist.  If the record is new (blank), then this will generate an error.

This will remove one or more fields from the database.  It does not matter if the field does not exist.

This will remove one or more fields from the database based on a criteria.  If the criteria is true, then the fields are cleared.  It does not matter if the field does not exist.

This will remove one or more fields from the primary (opened) database.  This supports clearing data in a new record.  New records are placed at the end of the database and you are responsible for resorting the database if required.

Think of this action as a light-weight join.  It opens the database (sCID,sTID) and finds the first record that satisfies the Criteria.  Then it copies the fields specified into the currently open record. This will not throw an error if the record is new. 

This action will create a database using the CID/TID and Filename.  If the database is already created this action proceeds normally.  If, for some reason, the database could not be created or opened normally, then this action returns an error and the script will stop. 

This will remove all records from the specified database where the criteria evaluates to True or non-zero.  The database remains if all records are deleted.

PDAT Professional Only: The deleteStyle parameter is a string parameter defined as:

    "R", "r", "Remove": Physically removes the record from the database.  This should only be used if you application does not support conduits.

    "D", "d", "Delete": Marks the record for deletion and removes the data.  The record becomes "invisible" to the app.

    "A", "a", "Archive": Marks the record for deletion, but does not remove the data.  The record becomes "invisible" to the app.

NOTE: If you delete the record that is being displayed on your form (e.g. a record edit form), that record may remain defined but in a "new" state.

This will remove all duplicate records from the specified database where the KeyField matches.  The first of a set of duplicate records is retained.  This is a sequential delete so it will be a lengthy operation, however, record order is maintained.  To perform a comparison on multiple fields, you first must make a key field from the concatenated values using the db.Set action.  

Example Script for multiple duplicate check:

db.Set Test, DATA, TFLD, text, "LNAM & FNAM"
db.Delete.Dups Test, DATA, TFLD
db.Clear Test, DATA, TFLD

The above example first creates a test field (TFLD) from the last name (LNAM) and first name (FNAM) fields.  Then it deletes duplicates based on the test field (TFLD).  Lastly, it deletes the remaining TFLD field.

The db.Delete.DupsNC action is identical to db.Delete.Dups with the exception that when comparing strings, a caseless comparison is performed.

PDAT Professional Only: The deleteStyle parameter is a string parameter defined as:

    "R", "r", "Remove": Physically removes the record from the database.  This should only be used if you application does not support conduits.

    "D", "d", "Delete": Marks the record for deletion and removes the data.  The record becomes "invisible" to the app.

    "A", "a", "Archive": Marks the record for deletion, but does not remove the data.  The record becomes "invisible" to the app.

This operation should be done when not in the primary data editing form.

Silently deletes the current record from the primary (open) database.  If the record is new, then this will generate an error.  If the the record being deleted is the last record in the database, the new "last" record will become active.

NOTE: Deleting all records in your database will result in a new record being created.

Exports records that match the criteria. For the DocNameExpression, the first record of the database is accessible by field name.  If you want to provide a literal name, you will have to double and single quote it as "'My Doc'" since the single-quoted string is a valid string expression.  TextExpression is written to the DOC file only if the criteria proves true for that record.  A doc file is created regardless of if any records are written to it.

Exports records that match the criteria. For the TitleExpression, the first record of the database is accessible by field name.  If you want to provide a literal name, you will have to double and single quote it as "'My Doc'" since the single-quoted string is a valid string expression.  TextExpression is written to the Memo file only if the criteria proves true for that record.  A doc file is created regardless of if any records are written to it.  NOTE: There is a limit to the size of memos of around 4 thousands bytes per memo however, if your database being exported is larger than that, then this action will create additional memos with the same title following the first one.

The db.Find.Rec searches the entire open database matching each record against the criteria specified.  If found, then that record is made active.  If not found, the current record remains active.  db.FindNext.Rec will start searching the database at the record following the current record.   db.FindPrev.Rec will start searching the database at the record before the current record.

The db.Find.RecEx and db.FindNext.RecEx / db.FindPrev.RecEx actions support branching.  If a record is found, then it branches to the following action.  If the record is not found, then it will skip the next action and execute the following action. 

Action btnTest
   db.Find.RecEx "LNAM = Stash({LNAM})"
   Goto +2
   Goto +3
   au.Alert.Custom ResultAlert, "Name was found"
   Goto +2 
   au.ALert.Custom ResultAlert, "Name was NOT found"
EndAction

This powerful action will evaluate the expression, and use the integer result of the expression as the new jump target.  The result may be negative (branch backwards) or positive (branch forward) and if the value is 0 or out-of-bounds of the number of actions, then the script is effectively halted. 

Action btnTest   
   db.goto "val(USER)"
   Goto @Choice0
   Goto @Choice1
   Goto @Choice2
@Choice0:
   db.Alert "Choice 0 was selected"
   Goto @Continue 
@Choice1:
   db.Alert "Choice 1 was selected"
   Goto @Continue 
@Choice2:
   db.Alert "Choice 2 was selected"
   Goto @Continue 
@Continue:
EndAction

This powerful action will evaluate the expression, and if the expression evaluates to a positive number greater than zero, will make that the target form ID and jump to that form.   This can be used to jump to random forms, jump to forms selected from a popup list, etc.

This action will test the criteria and if it evaluates to true, then will continue to execute the script.  If the criteria fails, the script is halted and the alert you specified from your application is displayed.

Tests if criteria evaluates to false and continues the script if so.  If the criteria evaluates to true, then it will stop the script.

db.If.True will test if criteria evaluates to true and continues the script if so.  If the criteria evaluates to false, then it will stop the script.

db.If.TrueEx will test if criteria evaluates to true and branch to the next action if true, of the 2nd action if false.  The script does not stop.

The following example displays a the extended db.If.TrueEx:

Action btnTest
   db.if.True "FNAM=''"
   Goto +2
   Goto +3
   db.Alert.Custom ResultAlert, "[LNAM]"
   Goto +2 
   db.Alert.Custom ResultAlert, "[LNAM] & ', ' & [FNAM]"
EndAction

Used to create filtered databases that contain only selected records which can update a master database. If the keyset database exists, it will first be deleted before the query is performed.  This is similar to Append, but adds KID, a field you specified to hold the keyset Link ID.

This is identical to db.keyset, but appends records to the keyset database.  If the database does not exists then it is created.

This action reads the keyset database and searches for each record in the master database.  If the keyset record is found in the master, then the master is updated with the new value.  If the keyset record is not found, then it is assumed to be a new record and is appended to the master database.  There is no "delete" detection, so you should handle deletes by marking records for delete, updating the master, then deleting the records from the master (and keyset, if you are wanting to keep it around).

This action will not work if there is no master database.  If there is a chance that your master database will not exist, then call the db.Create action before calling this to create a database (if needed).

Renumbers a database field based on the record number (starting at 1).   This is the same as setting a record to the expression "RecNo()"

This will renumber a given database using the unique Palm OS record ID.  This is a large number that will not change as long as the record does not get deleted.  It is the same value returned by the function RecID().

This is used to check-mark records that match a criteria.  

Sets the "fld" to the value of expression for the entire database.   If criteria is provided, then only those records matching Criteria will have the expression set.  This action does not clear the existing contents if criteria is provided. 

Fld-Type is a string with any of these values:

• "string", "text" - for any string field
• "number", "num" - for numbers (stored as strings) 
• "bool", "check" - for boolean (checkbox) values
• "icon" - for DataIcon values (these are numeric 0-1000)
• "date", "time" - for date or time fields
• "alarm", "datetime" - for alarm fields (note: assigning a value to an alarm field does not set the alarm, but it does set the date/time which may have other purposes).

The db.SetEx action is set up to take multiple sets of Fld, Fld-Type, and Expression parameters so you perform multiple calculations with one action.  This reduces both the flicker and increases the speed of the calculations.  The speed is increased proportionally with the number of calculations performed.  Expressions are calculated left to right so if you calculate a field in the first and use the field in the second expression, then the use will be the value of the calculated value, not the original value.  The Criteria parameter, if provided, applies to all the calculations in the action,

NOTE:  DINKs fields are not supported.

Sets the "fld" to the value of expression for the current record.   This supports creating a new record.  New records are placed at the end of the database and you are responsible for resorting the database if required.

Fld-Type is a string with any of these values:

• "string", "text" - for any string field
• "number", "num" - for numbers (stored as strings) 
• "bool", "check" - for boolean (checkbox) values
• "icon" - for DataIcon values (these are numeric 0-1000)
• "date", "time" - for date or time fields
• "alarm", "datetime" - for alarm fields (note: assigning a value to an alarm field does not set the alarm, but it does set the date/time which may have other purposes).

The db.Set.RecEx action is set up to take multiple sets of Fld, Fld-Type, and Expression parameters so you perform multiple calculations with one action.  This reduces both the flicker and increases the speed of the calculations.  The speed is increased proportionally with the number of calculations performed.  Expressions are calculated left to right so if you calculate a field in the first and use the field in the second expression, then the use will be the value of the calculated value, not the original value.

NOTE:  DINKs fields are not supported.

This allows the evaluation stack to be adjusted for more complicated expressions (or simpler ones if adjusting downward).  The amount of memory is proportional to the size of the stack.  By default, the stack size is set to 30.  This is sufficient for 99% of applications.  If your expression is VERY complicated, then you may need to increase it.  To estimate the size of the stack needed, you must consider the maximum depth of nested terms and all operands and function calls within the nested expression.

Some examples:

In general, if you are having problems with a big expression with lots of function calls and parans, then increase the stack by 10 at a time.  You probably don't want to go over 100.

The StackSize affects all expressions that are executed after it until it is changed.

This action is available only with the PDAT 6.0 Pro Script Compiler due to memory constraints.

If fields are provided, then this will remove those fields from the stash file database.  If no fields are provided, then all fields are cleared from the stash file.  There are no warnings.

This action will evaluate each of the expressions and assign them to fields in the stash file database.  This essentially creates a "global" set of fields or a better clipboard.   You must include at least one set of data (Fld, Type, Expression) but you may include more.

You can access any of the stashed data using the Stash( ) function.  You do not need to have an open record to use this action.  This means you should be able to use it in the eventStartup script or other places where there is no current record active.

Fld-Type is a string with any of these values:

• "string", "text" - for any string field
• "number", "num" - for numbers (stored as strings) 
• "bool", "check" - for boolean (checkbox) values
• "icon" - for DataIcon values (these are numeric 0-1000)
• "date", "time" - for date or time fields
• "alarm", "datetime" - for alarm fields (note: assigning a value to an alarm field does not set the alarm, but it does set the date/time which may have other purposes).

NOTE:  DINKs fields are not supported.

This action will create a stash file using the CID/TID and Filename.  It also ensures that there is a single record defined.  If, for some reason, the database could not be created or opened normally, then this action returns an error and the script will stop.   This action is best used in the startupEvent, but it may be used anywhere.  You may also use it multiple times with different CreatorID/TypeID pairs - though only the last one defined will be the active one.

If there is existing data in the stash file, it remains.  To clear out existing data, either delete the stash file before this action, or use the db.Stash.Clear to clear selected fields. 

All actions in this library that process an entire database display a small, framed, message as the processing is performed.  The color of the frame is controlled by colorIndex and is a number between 0 and 250 but it defaults to UIFrameColor (slightly purple).  Each action provides a default message which can be overridden with this action.  Once set, you must set the original text back by setting the message to "default".   

There are a couple of things to keep in mind about this action and status messages in general.  If you have turned off redraw in your script, then no status messages will be displayed at all.  If you leave it on, then the status messages are display, but there is a flicker as they are being erased for the next action.

Sets a form to use the CID, TID, Filename (FName) for Form ID "FormID" and Table ID "TableID". FormID or TableID may be 0 if there is no table.

Here are the conventions I use to use and document the evaluator:

Database Fields

You can reference database and record fields in one of two ways: By value or by reference.  The "by value" means that you want the field's value (or contents) from the record or database.  The "by reference" means that the field name itself is the value.  You'd use "by value" most of the time as it gets you the value you are mostly interested in.  However, when you need to pass the name of the field to a function, you would use the "by reference" form.

• [FLDX] = Field Value - the normal method of getting a field's value.
• {FLDX} = Field Reference - normally used when you pass a field name to a function.
• FLDX = Shorthand for a Field Value.  This must not be a fn or constant name and consist of only A-Z and 0-9. For all else, use [FLDX] form.

String Literals

• All strings in are single-quoted (e.g. 'Rick Sands')
• Escape sequences start with "\" and have the following codes:
• \\ Replace with a back-slash \
• \n Replace with a line-feed
• \q Replace with a double-quote
• \s Replace with a single-quote
• \4 Resplace with a dollar-sign ("$")
• \nnn Replace with char value nnn (nnn range is 000-255)

Constants

• true = 1
• false = 0

Operators

• String concatenation: &
• Unary math: +,-
• Binary math: +,-,*,/
• Integer or float raised to a integer power: ^
• Equality operators: : =, <>, <, >, <=, >=
• Binary Logical operators: AND, OR
• Unary logical operator: NOT (for floats, NOT is treated as negating)

Data Types and Calculations

When performing math, two integer values will always have an integer result (e.g. 10 / 3 = 3).  If a floating point number is involved in the expression, then the result is always a floating point (e.g. 10 / 3.0 = 3.33333).

The concatenation operation ("&") will convert numbers to a string so 'Rick' & 8 = 'Rick8', also 32 & 5 = '325'.  This avoids having to constantly use the STR(x) function to convert numbers to strings.  Dates, times, and field references, when implicitly converted to a string are converted as a number, so 1am would be the string '60' (60 minutes since midnite).

For logical operators, both operands must be strings to kick in the string comparisons.  You cannot use AND, OR, NOT with strings.  For floats, NOT is treated as a negating operator.

MathLib Functions Support

None!  I make no claim to knowing anything about the functions contained in MathLib.  Your best bet is to consult the MathLib documentation and lookup the functions that are supported here in the MathLib Function Reference.

Functions Parameter and Return Types Notation

• x = anything (string, integer, float, or variable ref, or null)
• n = integer, float
• s = string
• i = integer
• d = integer date (PDAT Date type - number of days since 1/1/1904)
• t = integer time (PDAT Time type - number of minutes since midnight)
• a = alarm time (PDAT Alarm type = number of seconds since 1/1/1904)
• v = variable reference (e.g. {NAME} ie curly-bracketed)

i = cmp(s1, s2)

x = choose(i, x1, x2, x3...)

x = iif(iTest, xTrue, xFalse)

i = mat(xTarget, xTest1, xTest2...)

i = missing({vfld})

i = def({vfld})

s = char(s, i)

s = clipboard()

i = crc(s, i)

s 	= extract(src, target, index)

s = lcase(s)

s = left(s, i)

i = len(s)

s = lpad(s, x)

s = mid(s, iStart, iCount) 

i = pos(src, target)

s = right(s, i)

s = rightTo(s, i)

s = rpad(s, x)

s = spc(x)

s = ucase(s)

s = fix(n, i)

s = loc(n, cDP, cComma)

s = str(n)

n = val(s)

s = FmtDate(s, d)

^<valueType><formatModifier>

^0z ^2l ^4r

i = day(d)

i = month(d)

i = year(d)

i = qtr(d)

d = toDate(i,i,i)

s = DateStr(d)

x = today(i)

i = hour(t)

i = min(t)

t = toTime(iHr, iMin)

s = timeStr(t)

x = now(i)

d = adate(a)

t = atime(a)

i = RecCnt()

i = RecID()

i = RecNo()

s = dname()

i = dcnt({vCID},{vTID})

x = dfld({vCID},{vTID},RecNo,{vfld})

x = dsum({vCID},{vTID},{vfld})

x = davg({vCID},{vTID},{vfld})

x = dmin({vCID},{vTID},{vfld})

x = dmax({vCID},{vTID},{vfld})

s = field(id)

s = popup(id)

i = checkbox(id)

i = radio(id)

s = list(id)

i = listI(id)

i = slider(id)

i = Rnd(i)

i = Abs(i)				z

MathLib Function Reference

I make no claim to knowing anything about the functions contained in MathLib.  Your best bet is to consult the MathLib documentation.

This program is not Freeware.  It is Shareware.  This means that you can, and should, try the demo out before buying.  Shortly after you register via PayPal you will receive an unlock key that will enable developing with this library.

 The cost of this package is US$12.95.

Primary support for this library is at the PDAT Nuts & Bolts Support Forum at www.PDATNutsAndBolts.com.

You can always contact me at:  email: Rick@SandsUSA.com or at my site http://www.SandsUSA.com.

"The Software" is "Database Extreme Library" aka "PDATDBXLib.prc" by Richard R. Sands dba Sands USA.

DISCLAIMER #1 - MUST READ

This product is an "After-Market" utility for PDA Toolbox(tm) and as such, is subject to obsolescence by changes in PDA Toolbox or the Palm OS(tm) itself.  This cannot be prevented.  I may choose to stop or limit development and support of this product if such situation occurs. 

USER LICENSE AGREEMENT

This Agreement sets forth your licensed rights to use "The Software" and is granted to you upon condition that you accept the terms of this license. Your electronic indication of agreement, or your use of the program constitute acceptance of all of the terms of this license.

The program copy and documentation are furnished to make "The Software" available for your use and remain the property of Sands USA.

IF YOU DO NOT AGREE WITH ANY PART OF THIS LICENSE, DO NOT USE THIS SOFTWARE. Delete "The Software" and all associated files from all media on which it has been copied. 

LICENSE TERMS AND CONDITIONS

THE LICENSED PRODUCT
"The Software" comprises copyrighted computer programs and utilities for the reporting of Palm OS(tm) application databases (PRC) created by the PDA Toolbox(tm) Application Generator. The Licensed Product in its entirety is protected by US and foreign copyright.  YOU MAY NOT DISTRIBUTE THE LICENSE CODE provided to you.

YOUR USE OF THE LICENSED PRODUCT
General Use. You have the right to use "The Software" with PDAT/Advanced and to distribute the library file "PDATDBXLib.prc"  or "PDATDBXLibRT.prc" but license codes, or other information about this library.  For those purposes, you have the right to install the "The Software" and any associated files on one (1) computer. Use of "The Software" on a network or any other arrangement by which its functions are accessible to more than one user at a time is not permitted. 

LIMITATIONS ON USE
General Use Limitations. You have no right to reproduce, transfer, publish or otherwise distribute either the "The Software" software, or any components or documentation provided.

ALL RIGHTS NOT SPECIFICALLY GRANTED BY THIS LICENSE ARE RESERVED BY SANDS USA. 

WARRANTIES, WARNING, DISCLAIMER

Warning and Disclaimer of All Warranties. THE PROGRAM IS FURNISHED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, IN ALL JURISDICTIONS WHERE ALL WARRANTIES MAY BE DISCLAIMED IN THE LICENSING OF INTELLECTUAL PROPERTY.

PDAT/Advanced is Copyrighed by Richard R. Sands dba Sands USA

Database Extreme Library is Copyrighed by Richard R. Sands dba Sands USA

PDAT Toolbox is Copyrighted by Paul Prejean

Nutshell executable and documentation are Copyright ©2002-2004 by Ecamm Network. All rights reserved.

RsrcEdit is apparently not copyrighted by Quartus, but they are the caretakers of RsrcEdit.

Database Extreme Documentation Copyright (C) 2002-2004 Richard R. Sands dba Sands USA
All Rights Reserved

Microsoft Windows, Microsoft Office, Microsoft Visual Studio, Microsoft Visual Studio .NET, Microsoft Visual Basic, and Internet Explorer are Trademarks of, and copyrighted by, Microsoft Corporation

PDA Toolbox Professional is copyrighted by Paul R. Anderson and Richard R. Sands

RsrcEdit is apparently not copyrighted but maintained at www.Quartus.net

And Finally, ...

palmOne, Zire, Tungsten, Treo, Blazer, VersaMail, Addit, Handspring, stylizations and design marks associated with all the preceding, and trade dressassociated with palmOne, Inc.’s products, are among the trademarks or registered trademarks owned by or exclusively licensed to palmOne, Inc. All other brand and product names are or may be trademarks of, and are used to identify products or services of, their respective owners.