All Classes and Interfaces
Class
Description
Base input class for all Q actions.
Abstract base class for any qqq-action's output.
Base class for all Backend-module-API Actions
Base class for all Filesystem actions across all modules.
Base class for the data returned in rendering a block of a specific type.
Base class for individual endpoint specs.
Base class for the Extract logic of Streamed ETL processes.
Base class for all (local) Filesystem actions
Base class for all BackendMetaData for all filesystem-style backend modules.
Extension of QTableBackendDetails, with details specific to a Filesystem table.
Base class for rendering qqq HTML dashboard widgets
Base class for the Load (aka, store) logic of Streamed ETL processes.
Base class for all core actions in the Memory backend module.
This class is for merging duplicate records in a table.
Record to store the config for this process - e.g., what fields invalid input: '&' tables are used.
Abstract base class in hierarchy of classes that know how to construct invalid input: '&'
populate QMetaDataObject instances, based on input streams (e.g., from files).
Version of AbstractQQQApplication that assumes all meta-data is produced
by MetaDataProducers in (or under) a single package.
Baseclass that combines multiple specs together into a single "version" of
the full qqq middleware.
Base class for all mongoDB module actions.
Abstract class that a table can specify an implementation of, to provide
custom actions after a delete takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions after an insert takes place.
after a file is read, "customize" its contents - e.g., do regex, or append
contents, or do whatever we like to it.
Abstract class that a table can specify an implementation of, to provide
custom actions after an update takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions before a delete takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions before an insert takes place.
allow the customizer to specify when it should be executed as part of the
insert action.
Abstract class that a table can specify an implementation of, to provide
custom actions before an update takes place.
Base class for QQQ Actions (both framework and application defined) that
have a signature like a BiConsumer - taking both Input and Output objects as
parameters, with void output.
Base class for QQQ Actions (both framework and application defined) that
have a signature like a Function - taking an Input object as a parameter,
and returning an Output object.
For bulk-loads, define where a QField comes from in an input data source.
Enum to define the types of sources a mapping may use
Base class to provide the definition of a QQQ-based application.
Base class for all core actions in the RDBMS module.
Base class for input wrappers that end up running scripts (ExecuteCodeAction)
Base class for all S3 filesystem actions
Base class for all SFTP filesystem actions
Base class for input for any qqq action that works against a table.
This class is for transforming records from a Source table to a Destination table.
Record to store the config for this process - e.g., what fields invalid input: '&' tables are used.
Base class for the Transform logic of Streamed ETL processes.
Base class for rendering qqq dashboard widgets
Exception thrown doing authentication
Utility methods to be shared by all of the various Actions (e.g., InsertAction)
For actions that may want to set a timeout, and cancel themselves if they run
too long - this class helps.
Types of adornments that can be added to fields - with utilities for
constructing their values.
Define an "aggregate", e.g., to be selected in an Aggregate action.
Generic widget that does an aggregate query, and presents its results
as a table, using group-by values as both row invalid input: '&' column labels.
Action to run an aggregate against a table.
Input data for the Count action
Interface for the Aggregate action.
Output for an aggregate action
Classes that support doing data aggregations (e.g., count, sum, min, max, average).
Model containing datastructure expected by frontend alert widget
Widget that can add an Alert to a process screen.
Deprecated.
Comparator for strings that are a mix of alpha + numeric, where we want to
sort the numeric substrings like numbers.
Meant to serve as the key in a Memoization where we actually don't need a parameter.
Meta-data to provide details of an API backend (e.g., connection params)
QQQ Backend module for working with API's (e.g., over http(s)).
settings that the API backend module can get from a backend variant.
optional interface that can be added to an ApiFieldCustomValueMapper to
signal that the customizer knows how to work in bulk.
utility methods for working with fields
In addition to the standard/known fields in this entity, you can also add
name/value pairs of security key values - e.g., a clientId field
Object injected into script context, for interfacing with a QQQ API.
Extension of QTableBackendDetails, with details specific to an API table.
Should work as well for https://semver.org/spec/v2.0.0.html or https://calver.org/
or simple increasing integers, or ?
Frontend-version of objects that are parts of the app-hierarchy/tree.
Type for an Node in the app tree.
definition of a qqq table that is "associated" with another table, e.g.,
managed along with it - such as child-records under a parent record.
Interface to be implemented (as lambdas), for working with AsyncJobManager.
Argument passed to an AsyncJob when it runs, which can be used to communicate
data back out of the job.
Class to manage running asynchronous actions, and working with their statuses.
Possible states for an async job's "running"-ness.
Object to track current status of an async job - e.g., its state, and some
messages from the backend like "x of y"
Class that knows how to Run an asynchronous job (lambda, supplier) that writes into a
RecordPipe, with another lambda (consumer) that consumes records from the pipe.
block that plays an audio file
Insert 1 or more audits (and optionally their children, auditDetails)
Takes care of managing the foreign key tables (auditTable, auditUser).
Object to accumulate multiple audit-details to be recorded under a single
audit per-record, within a process step.
Input object for the audit action - an object which contains a list of "single"
audit inputs - e.g., the data needed to insert 1 audit.
Input data to insert a single audit record (with optional child record)..
Meta-data to provide details of an Auth0 Authentication module
QQQ AuthenticationModule for working with Auth0.
enum of possible values for a record's Automation Status.
Table-automation meta-data to define how this table's per-record automation
status is tracked.
Enum of possible types of per-table, per-record automation-status tracking.
Utility class for backend modules that need to do filter operations.
Simple interface that Backend Steps (e.g., code within processes) must implement
Subclass of RunBackendStepInput, meant for use in the postRun of the transform/load
steps of a Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a preview (e.g., first n).
Subclass of RunBackendStepOutput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a preview of the records - e.g.,
the first n.
Configs for how a backend that uses variants works.
interface to be implemented by enums (presumably) that define the possible
settings a particular backend type can get from a variant record.
Utility methods for backends working with Variants.
Record error message for when some bad input caused the issue (e.g., a missing
value, or an illegal value).
element of BrandingMetaData - content to send to a frontend for showing a
user across the whole UI - e.g., what environment you're in, or a message
about your account - site announcements, etc.
interface to define keys for where banners should be displayed.
Base class for utility functions that make up the unique ways in which an
API can be implemented.
enum of which HTTP Method the backend uses for Updates.
Basic version of a C3P0 Connection Customizer used by QQQ - that does things
expected for an RDBMS backend - specifically:
- runs queriesForNewConnections, if they are set.
Class for storing all basepull configuration data
marker - used to indicate that a step is meant to be used for basepull extracts.
instance validator plugin, to ensure that a process which is a basepull uses
an extract step marked for basepulls.
Base class for "query" (e.g., read-operations) action interfaces (query, count, aggregate).
Note that much of this class came from the old (old) QueryManager class.
Base class for the StreamedETL preview invalid input: '&' execute steps
Basic implementation of a possible value provider, for where there's a limited
set of possible source objects - so you just have to define how to make one
PV from a source object, how to list all of the source objects, and how to
look up a PV from an id.
BackendStep for performing the Cleanup step of a basic ETL process - e.g.,
after the loading, delete or move the processed file(s).
BackendStep for collecting the file names that were discovered in the
Extract step.
Function body for performing the Extract step of a basic ETL process.
Function body for performing the Load step of a basic ETL process.
Definition for Basic ETL process.
Function body for performing the Extract step of a basic ETL process.
Basic definition of an operation (e.g., an endpoint exposed in the API).
Basic version of a response from a spec/endpoint.
Definition for Basic process to run a report.
Basic implementation of interface for identifying schedulable things
BigDecimal version of data aggregator
A link used within a (widget) block.
marker-interface for classes (enums, actually) used to define the "slots"
within a widget-block that can have links or tooltips applied to them.
Marker interface for classes that define the "styles" that can be customized
within a particular widget-block type.
A tooltip used within a (widget) block.
Marker interface for classes that define the values that can be returned for
a particular widget-block type.
Version of excel styler that does bold headers and footers, with basic borders.
Version of POI excel styler that does bold headers and footers, with basic borders.
Subclass of RecordPipe, which uses a buffer in the addRecord method, to avoid
sending single-records at a time through postRecordActions and to consumers.
Implementation of a code execution logger that builds a scriptLog and 0 or more
scriptLogLine records - but doesn't insert them.
Load step for bulk-delete.
Transform step for generic table bulk-insert ETL process
Load step for generic table bulk-edit ETL process
Transform step for generic table bulk-edit ETL process
Extract step for generic table bulk-insert ETL process
This step does a little bit of transforming, actually - taking rows from
an uploaded file, and potentially merging them (for child-table use-cases)
and applying the "Mapping" - to put fully built records into the pipe for the
Transform step.
step before the upload screen, to prepare dynamic help-text for user.
Transform step for generic table bulk-insert ETL process
A row of values, e.g., from a file, for bulk-load
Given a bulk-upload, create a suggested mapping
Specialized error for records, for bulk-load use-cases, where we want to
report back info to the user about the field invalid input: '&' value.
this is the model of a saved bulk load profile - which is what passes back
and forth with the frontend.
Utility methods for working with records in a bulk-load.
utility to build BulkLoadTableStructure objects for a QQQ Table.
Specialized error for records, for bulk-load use-cases, where we want to
report back info to the user about the field invalid input: '&' value.
a button (for a process - not sure yet what this could do in a standalone
widget?)
Meta-data, to assign to a table which is a "cache of" another table.
Action handler for running the cancel step of a qqq process
Things that can be done to tables, fields.
record containing the values managed by QContext.
Mode for filesystem backends: are all records in a single file, or are there
many files?
Field behavior that changes the case of string values.
Version of map where string keys are handled case-insensitively.
Model containing datastructure expected by frontend bar chart widget
Standard/re-usable post-insert customizer, for the use case where, when we
do an insert into table "parent", we want a record automatically inserted into
table "child".
value that goes inside a QMetadataProducingEntity annotation, to control
the generation of a QJoinMetaData
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QJoinMetaData, based on a
QRecordEntity and a ChildTable sub-annotation.
Model containing data structure expected by frontend ChildRecordList widget
Generic widget for display a list of child records.
value that goes inside a QMetadataProducingEntity annotation, to control
the generation of a QWidgetMetaData - for a ChildRecordList widget.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a ChildRecordList QWidgetMetaData, to
produce a QJoinMetaData, based on a QRecordEntity and a ChildTable sub-annotation.
value that goes inside a QMetadataProducingEntity annotation, to define
child-tables, e.g., for producing joins and childRecordList widgets
Generic implementation of AbstractMetaDataLoader, who "detects" the class
of meta data object to be created, then defers to an appropriate subclass
to do the work.
Utilities for reading classes - e.g., finding all in a package
A log message, which can be "collected" by the QCollectingLogger.
Utility class for working with Collections.
Utility for verifying that the ColumnStats process works for all fields,
on all tables, and all exposed joins.
This is a single-step process used to provide Column Statistics.
Extension of a BasicOperation that adds the full openAPI Method object.
Data used to render a Composite Widget - e.g., a collection of blocks
Version of AbstractQQQApplication that assumes all meta-data is defined in
config files (yaml, json, etc) under a given directory path.
Class to manage access to JDBC Connections.
Settings for a connection pool (if your backend is configured to use one).
interface for classes that can provide jdbc Connections for an RDBMS backend.
Action to convert a string of HTML to a PDF!
Action to run a count against a table.
Hash that provides "counting" capability -- keys map to Integers that
are automatically/easily summed to
Input data for the Count action
Interface for the Count action.
Output for a count action
Possible behaviors for doing interpretValues on a filter, and a criteria
has a variable value (either as a string-that-looks-like-a-variable,
as in ${input.foreignId} for a PVS filter, or a FilterVariableExpression),
and a value for that variable isn't available.
class to give a human-friendly descriptive string from a cron expression.
Field display behavior, to add a human-redable tooltip to cron-expressions.
CSV export format implementation
Adapter class to convert a CSV string into a list of QRecords.
Interface for customizer on a QReportDataSource's query.
Field Display Behavior class for customizing the display values used
in date-time fields
Enum to define various "levels" of group-by for on dashboards that want to
group records by, e.g., year, or month, or week, or day, or hour.
a default implementation of MetaDataFilterInterface, that is all noop.
Action to delete 1 or more records.
Input for a Delete action.
Interface for the Delete action.
Output for a delete action
Process used by the delete bulkLoadProfile dialog
Process used by the delete view dialog
DeleteSharedRecord: {tableName; recordId; shareId;}
Utility methods to help with deserializing JSON streams into QQQ models.
Subclass of record pipe that ony allows through distinct records, based on
the set of fields specified in the constructor as a uniqueKey.
Model containing datastructure expected by frontend divider widget
Generic widget for showing a divider
Audit for a standard DML (Data Manipulation Language) activity - e.g.,
insert, edit, or delete.
Input object for the DML audit action.
Output object for the DML audit action.
custom code that can run when user downloads a file.
specialization of bad-input status message, specifically for the case of
a duplicated key (e.g., unique-key validation error)
Field behavior that sets a default value for a field dynamically.
Meta Data Producer for DynamicSiteProcess
EditSharedRecord: {tableName; recordId; shareId; scopeId;}
for use-cases where a metaDataProducer directly adds its objects to the
qInstance, then this empty object can be returned.
generic middleware input that has no fields.
Backend module for a table based on a java enum.
Excel export format implementation - built using fastexcel library
Excel export format implementation using POI library, but with modifications
to actually stream output rather than use any temp files.
style customization points for Excel files generated via our streaming POI.
Utility class for working with exceptions.
Action to execute user/runtime defined code.
Process step to execute a report.
Action to generate an export from a table
At this time (future may change?)
Input for an Export action
Output for an Export action
Utility for verifying that the ExportAction works for all tables, and all
exposed joins.
Interface for various export formats to implement.
interface for classes that can be used to customize visual style aspects of
exports/reports.
Version of ExtractViaQueryStep that knows how to set up a basepull query.
Generic implementation of an ExtractStep - that runs a Query action for a
specified table.
Interface for classes that know how to apply styles to an Excel stream being
built by fastexcel.
Special fancy things that fields might do in UIs.
Wrapper (record) that holds a QFieldMetaData and a QTableMetaData -
With a factory method (`get()`) to go from the use-case of, a String that's
"joinTable.fieldName" or "fieldName" to the pair.
Interface for (expected to be?)
Marker interface for a field behavior which you might want to send to a
frontend (e.g., so it can edit values to match what'll happen in the backend).
Interface to mark a field behavior as one to be used during generating
display values.
a default implementation for this behavior type, which does nothing.
Interface to mark a field behavior as one to be used before a query filter
is executed.
Define, for a field, a lock that controls if users can or cannot see the field.
Model containing data structure expected by frontend FieldValueListData widget
(local) Filesystem backend meta data.
QQQ Backend module for working with (local) Filesystems.
Interface to add additional functionality commonly among the various filesystem
module implementations.
Checked exception to be thrown from actions within this module.
Class to serve as a template for producing an instance of a process invalid input: '&' tables
that provide the QQQ service to manage importing files (e.g., partner feeds on S3).
Process MetaData Builder for FilesystemImporter process.
BackendStep for FilesystemImporter process
Job is to:
- foreach file in the `source` table (e.g., a ONE-type filesystem table):
- optionally create an archive/backup copy of the file
- create a record in the `importFile` table
- parse the file, creating many records in the `importRecord` table
- remove the file from the `source` (if so configured (e.g., may turn off for Read-only FS))
Define the field names (keys) to be used in the backendDetails structure
under Records from this (these) modules.
(mass, streamed) storage action for filesystem module
Definition for Filesystem sync process.
BackendStep to sync two filesystem tables (copying the new files to a 3rd
location as well...)
(local) Filesystem specific Extension of QTableBackendDetails
Builder class to create standard style QTableMetaData for tables in filesystem
modules (avoid some boilerplate).
Model containing datastructure expected by frontend filter and columns setup widget
Display value formatter for fields which store a QQueryFilter as JSON.
Interface where we can associate behaviors with various use cases for
QQueryFilters - the original being, how to handle (in the interpretValues
method) how to handle missing input values.
Helper for Generating reports - to interpret formulas in report columns,
that are in "excel-style", ala: =MINUS(47,42) or
=IF(LT(ADD(${input.x},${input.y}),10,Yes,No)
An authentication module with no actual backing system - all users are treated
as anonymous, and all sessions are always valid.
Create a garbage collector process for a given table.
Utility methods for working with QQQ records and table actions inside user -
defined QQQ processes steps.
Action to generate a report.
Action to run a get against a table.
Input data for the Get action
Interface for the Get action.
Output for a Get action
GetSharedRecords: {tableName; recordId;} => [{id; audienceType; audienceId; audienceLabel; scopeId}]
For a given table (name) and API version, return the list of fields that apply
for the API.
Input-record for convenience methods
Process to find records with a bad automation status, and repair them.
QRecord Entity for HelpContent table
HelpContentFormat - possible value enum
Meta-data provider for table invalid input: '&' PVS's for defining help-content for other
meta-data objects within a QQQ app
after records are inserted, put their help content in meta-data
after records are updated, put their help content in meta-data
remove existing helpContent from meta-data when a record is deleted
in case a row's Key or Role was changed, remove existing helpContent from that key.
HelpContentRole - possible value enum
How a piece of help content is formatted.
Interface to be associated with a HelpContent, to identify where the content
is meant to be used (e.g., only on "write" screens, vs. on app home pages, etc).
class to contain http api responses.
block to display an image
Specialization of a QueryJoin, for when the join is added to the query,
not by the caller, but by the framework, because it is implicitly needed
to provide a security lock.
combine all unstructured fields of the record into a JSON blob in the "values" field.
an object which is intended to be constructed via a CodeReference, and,
moreso, after it is created, then the initialize method here gets called,
passing the codeRefernce in - e.g., to do additional initalization of the
object, e.g., properties in a QCodeReferenceWithProperties
Singleton class that provides a (non-persistent!!)
block to display an input field - initially targeted at widgets-in-processes
interface to define input sources - idea being, so QQQ can have its standard
ones (see QInputSource), but applications can define their own as well.
Action to insert one or more records.
Input data for the Insert action
Interface for the Insert action.
Output for an insert action
InsertSharedRecord: {tableName; recordId; audienceType; audienceId; scopeId;}
Instant version of data aggregator
Integer version of data aggregator
Class-level annotation to declare what fields should run through the variable
interpreter - e.g., to be replaced with env-var values at run-time.
Exception thrown by AsyncJobManager, not to indicate an error, per se, but
rather to indicate that a job has taken too long, as is now "going async".
Object to represent the graph of joins in a QQQ Instance.
Specification for (at least part of) how two tables join together - e.g.,
leftField = rightField.
Helper object used throughout query (and related (count, aggregate, reporting))
actions that need to track joins and aliases.
Type for a QJoin
JSON export format implementation
Adapter class to convert a JSON string into a QFieldMapping object
Adapter class to convert a JSON string into a list of QRecords.
Utility class for working with JSON.
temporary class, while we migrate from original way that variants were set up
e.g., by calling 'variantOptionsTableUsernameField', to the new way, using
the BackendVariantsConfig which uses a map of enum constants.
Model containing datastructure expected by frontend bar chart widget
List.of is "great", but annoying because it makes unmodifiable lists...
Hash that provides "listing" capability -- keys map to lists of values that
are automatically/easily added to
Report streamer implementation that just builds up a STATIC list of lists of strings.
Record to track where loader objects are - e.g., what file they're on,
and at what property path within the file (e.g., helps report problems).
record that tracks a problem that was encountered when loading files.
Function body to take care of loading the initial records to be used by a
process.
Action to load the details necessary to test a script.
Generic implementation of a LoadStep - that runs a Delete action for a
specified table.
Generic implementation of a LoadStep - that runs Insert and/or Update
actions for the destination table - where the presence or absence of the
record's primaryKey field is the indicator for which to do.
Generic implementation of a LoadStep - that runs an Insert action for a
specified table.
Generic implementation of a LoadStep - that runs an Update action for a
specified table.
LocalDate version of data aggregator
Useful things to do on a mac, when doing development - that we can expect
may not exist in a prod or even CI environment.
Model containing datastructure expected by frontend location widget
Implementation of a code execution logger that logs to LOG 4j
Implementation of ProcessTracerInterface that writes messages to the Logger.
Long version of data aggregator
Map.of is "great", but annoying because it makes unmodifiable maps, and it
NPE's on nulls...
Basic memoization functionality - with result timeouts (only when doing a get -
there's no cleanup thread), and max-size.
Object stored in the Memoization class.
In-memory version of aggregate action.
A simple (probably only valid for testing?)
In-memory version of count action.
In-memory version of delete action.
In-memory version of insert action.
In-memory version of query action.
Storage provider for the MemoryBackendModule
implementation of bulk-storage interface, for the memory backend module.
In-memory version of update action.
Generic ETL Load step for a merge duplicates process.
Definition for Standard process to merge duplicate records in a table.
Action to fetch top-level meta-data in a qqq instance.
Interface for customizations that can be injected by an application into
the MetaDataAction - e.g., loading applicable meta-data for a user into a
frontend.
Interface to be implemented by classes that are designed to help customize
meta-data objects as they're being produced, e.g., such as a table produced
via the QMetaDataProducingEntity, or maybe tables loaded by a qbit??
noop version of this interface - used as default value in annotation
Deprecated.
Input for the meta-data action
class that loads a directory full of meta data files into meta data objects,
and then sets all of them in a QInstance.
Output for a metaData action
Abstract class that knows how to produce meta data objects.
Version of AbstractQQQApplication that assumes all meta-data is produced
by MetaDataProducers in (or under) a single package (where you can pass that
package into the constructor, vs. the abstract base class, where you extend
it and override the getMetaDataPackageName method.
Help work with MetaDataProducers.
Interface for classes that know how to produce meta data objects.
Output object for a MetaDataProducer, which contains multiple meta-data
objects.
Interface to mark objects that can be produced by a MetaDataProducer.
A Mock implementation of the QModuleInterface.
Mock implementation of a FunctionBody.
Mocked up version of query action.
Mocked up version of delete action.
Mocked up version of insert action.
Mocked up version of query action.
Mocked up version of update action.
Wrapper around a MongoClient, ClientSession, and a boolean to help signal
where it was opened (e.g., so you know if you need to close it yourself, or
if it came from someone else (e.g., via an input transaction)).
Meta-data to provide details of a MongoDB backend (e.g., connection params)
QQQ Backend module for working with MongoDB
Extension of QTableBackendDetails, with details specific to a MongoDB table.
MongoDB implementation of backend transaction.
Help you use a multi-level map, such as:
Map[String, Map[String, Integer]] countryStateCountMap = new HashMap[]();
Where you always want to put new maps at the lower-level if they aren't there,
and similarly, you want to start with a 0 for the value under each (final) key.
Subclass of RecordSecurityLock, for combining multiple locks using a boolean
(AND/OR) condition.
Model containing datastructure expected by frontend bar chart widget
Model containing datastructure expected by frontend bar chart widget
Object to wrap a List, so that in case a caller provided an immutable List,
you can safely perform mutating operations on it (in which case, it'll get
replaced by an actual mutable list).
Object to wrap a Map, so that in case a caller provided an immutable Map,
you can safely perform mutating operations on it (in which case, it'll get
replaced by an actual mutable Map).
RDBMS action strategy for a field with a FULLTEXT INDEX on it in a MySQL
database.
subclass designed to be used when we want there to be an instance (so code
doesn't have to all be null-tolerant), but there's no one who will ever be
reading the status data, so we don't need to store the object in a
state provider.
Implementation of a code execution logger that just noop's every action.
Load step that does nothing.
Implementation of ProcessTracerInterface that does nothing (no-op).
Implementation of a TransformStep - it does nothing other than take input records
and sets them in the output
Record error message for when something couldn't be found (e.g., a request
to update a record, but it isn't in the backend).
Utility for working with security key, nullValueBehaviors.
Meta-data to provide details of an OAuth2 Authentication module
Implementation of OAuth2 authentication.
Provides all OAuth2 authentication related metadata to the QQQ engine
Exception to be thrown during OAuth Token generation.
Exception to be thrown by a request that uses OAuth, if the current token
is expired.
Entity bean for OutboundApiLog table
Simple container for two objects
Model containing datastructure expected by frontend parent widget
Specific meta data for frontend parent widget
Generic widget for display a parent widget with children of possible values,
child widgets, and child actions
Manage process to pause all quartz jobs
Record error message for when the user didn't have permission to do what they
were trying.
Define how a PicoCLI process gets data back to a QProcess.
Model containing datastructure expected by frontend pie chart widget
Full definition of a pivot table - its rows, columns, and values.
Functions that can be applied to Values in a pivot table.
Either a row or column grouping in a pivot table.
How a group-by (rows or columns) should be sorted.
a value (e.g., field name + function) used in a pivot table
Excel styler that does nothing - just takes defaults (which are all no-op) from the interface.
Excel styler that does nothing - just takes defaults (which are all no-op) from the interface.
Interface for classes that know how to apply styles to an Excel stream being
built by POI.
Runnable for the Polling Automation Provider, that looks for records that
need automations, and executes them.
extended version of TableAction, for sharding use-case - adds the shard
details.
Wrapper for a pair of (tableName, automationStatus)
Interface to be used by 2 records in this class - normal TableActions, and
ShardedTableActions.
Metadata specifically for the polling automation provider.
Interface to be implemented by enums which can be used as a PossibleValueSource.
FilterUseCase implementation for the ways that possible value searches
are performed, and where we want to have different behaviors for criteria
that are missing an input value.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QPossibleValueSource meta-data
based on a PossibleValueEnum
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QPossibleValueSource meta-data
based on a QRecordEntity class (which has corresponding QTableMetaData).
ThreadFactory implementation that puts a common prefix on all threads.
Version of PrepareReportStep for a report that runs off a single record.
Process step to prepare for running a report.
process payload shared the processes which are used as process-based-router
processes.
QRecord Entity for ProcessLock table
MetaData producer for Process Locks "system"
Record to hold either a processLock, or an unableToObtainProcessLockException.
QRecord Entity for ProcessLockType table
Utility class for working with ProcessLock table - creating, checking-in,
and releasing process locks.
input wrapper for an overload of the checkin method, to allow more flexibility
w/ whether or not you want to update details invalid input: '&' expiresAtTimestamp (e.g., so a
null can be passed in, to mean "set it to null" vs.
Action to fetch meta-data for a process.
Object that stores adjustments that a process wants to make, at run-time,
to its meta-data.
Input for meta-data for a process.
Output for a process-metaData action
Possible ways the steps of a process can flow.
Simple process summary result object, that lets you give a link to a filter
on a table.
For processes that may show a review invalid input: '&' result screen, this class provides a
standard way to summarize information about the records in the process.
Interface for objects that can be output from a process to summarize its results.
Interface for a class that can provide a ProcessSummary - a list of Process Summary Lines
Simple process summary result object, that lets you give a link to a record
in a table.
Helper class for process steps that want to roll up error summary and/or
warning summary lines.
Interface that can be plugged into the execution of a QProcess, that gets
callbacks from QQQ for events in the lifecycle of a process, which one may
wish to log or otherwise be aware of.
Specialization of process tracer message, to indicate a 'key record' that was
used as an input or trigger to a process.
Basic class that can be passed in to ProcessTracerInterface.handleMessage.
Model containing datastructure expected by frontend process widget
Generic widget for displaying a process as a widget
Common (maybe)?
Define some standard ways to format the value portion of a PossibleValueSource.
Abstract base class for any and all QQQ lambda handlers.
Interface shared by meta-data objects which can be placed into an App.
Second-generation qqq javalin server.
MetaData definition of an App - an entity that organizes tables invalid input: '&' processes
and can be arranged hierarchically (e.g, apps can contain other apps).
A section of apps/tables/processes - a logical grouping.
Annotation to place onto fields in a QRecordEntity, to mark them as associated
record lists
Exception thrown doing authentication
Meta-data to provide details of an authentication provider (e.g., google, saml,
etc) within a qqq instance
Interface for customizing behavior of an Authentication module.
This class is responsible for loading an authentication module, by its name, and
returning an instance.
Interface that a QAuthenticationModule must implement.
Enum to define the possible authentication types
Meta-data definition of a qqq service to drive record automations.
Enum to define the possible automation provider types
Meta-data to provide details of a backend (e.g., RDBMS instance, S3 buckets,
NoSQL table, etc) within a qqq instance
Jackson custom deserialization class, to return an appropriate sub-type of
A QBackendMetaData, based on the backendType specified within.
This class is responsible for loading a backend module, by its name, and
returning an instance.
Interface that a QBackendModule must implement.
Meta-Data to define a backend-step in a process in a QQQ instance.
Container wherein backend modules can track data and/or objects that are
part of a transaction.
Exception thrown when an API HTTP request failed due to a bad status code.
User-facing exception for when user provided bad or missing data in their request
QQQ base class for "Custom" lambda handlers.
extension of MetaDataProducerInterface, designed for producing meta data
within a (java-defined, at this time) QBit.
Interface for configuration settings used both in the production of meta-data
for a QBit, but also at runtime, e.g., to be aware of exactly how the qbit
has been incorporated into an application.
thrown by QBitConfig.validate() if there's an issue.
Meta-data to define an active QBit in a QQQ Instance.
interface for how a QBit's meta-data gets produced and added to a QInstance.
Meta-Data to define branding in a QQQ instance.
Exception thrown while executing custom code in QQQ.
Interface to provide logging functionality to QCodeExecution (e.g., scripts)
Interface to be implemented by language-specific code executors, e.g., in
qqq-language-support-${languageName} maven modules.
Interface for classes that can accept a QCodeExecutor object via a setter.
Utility to load code for running QQQ customizers.
Pointer to code to be ran by the qqq framework, e.g., for custom behavior -
maybe process steps, maybe customization to a table, etc.
Specialized type of QCodeReference that takes a lambda function object.
a code reference that also has a map of properties.
Possible types for Q-Code entities
Possible usages for Q-Code entities
QQQ log4j implementation, used within a QLogger, to "collect" log messages
in an internal list - the idea being - for tests, to assert that logs happened.
Helper class for QPicCliImplementation to build the Command
Types of UI Components that can be specified in frontend process steps.
A collection of thread-local variables, to define the current context of the
QQQ code that is running.
Possible query criteria field operators
Interface to be implemented by user-defined code that serves as the backing
for a CUSTOM type possibleValueSource
Type parameter `T` is the id-type of the possible value.
Abstract base class for all errors to be attached to QRecords.
Base class for checked exceptions thrown in qqq.
Annotation to place onto fields in a QRecordEntity, to add additional attributes
for propagating down into the corresponding QFieldMetaData
Jackson custom deserialization class, to return an appropriate sub-type of
A QBackendMetaData, based on the backendType specified within.
Meta-data to represent a single field in a table.
A section of fields - a logical grouping.
Possible data types for Q-fields.
A single criteria Component of a Query
Custom jackson deserializer, to deal w/ abstract expression field
Bean representing an element of a query order-by clause.
Bean representing an element of a query order-by clause - ordering by an
aggregate field.
Bean representing an element of a query order-by clause - ordering by a
group by
Exception thrown while generating reports
Version of QAppMetaData that's meant for transmitting to a frontend.
Definition of a UI component in a frontend process steps.
Version of an ExposedJoin for a frontend to see
Version of QFieldMetaData that's meant for transmitting to a frontend.
Version of QProcessMetaData that's meant for transmitting to a frontend.
Version of QReportMetaData that's meant for transmitting to a frontend.
Meta-Data to define a front-end step in a process in a QQQ instance (e.g.,
a screen presented to a user).
Version of QTableMetaData that's meant for transmitting to a frontend.
Version of a variant for a frontend to see
Version of QWidgetMetaData that's meant for transmitting to a frontend.
Meta-Data to define the Input Data for a QQQ Function
Meta-Data to define the Output Data for a QQQ Function
meta-data defintion of "Help Content" to show to a user - for use in
a specific "role" (e.g., insert screens but not view screens), and in a
particular "format" (e.g., plain text, html, markdown).
QQQ default or standard HelpRoles.
class to contain httpResponse data from closable responses
Icon to show associated with an App, Table, Process, etc.
Marker - that a piece of code should be ignored (e.g., a field not treated as
a @QField)
Field Mapping implementation that uses Integer keys (e.g., from a CSV file
WITHOUT a header row).
QQQ standard input sources -- the system, or users.
Container for all meta-data in a running instance of a QQQ application.
Methods for adapting qInstances to serialized (string) formats (e.g., json),
and vice versa.
As part of helping a QInstance be created and/or validated, apply some default
transformations to it, such as populating missing labels based on names.
Interface for additional / optional enrichment to be done on q instance members.
Utility methods for working with (dynamic, from a table) HelpContent - and
putting it into meta-data in a QInstance.
Exception thrown during qqq-starup, if a QInstance is found to have validation
issues.
Object used to mark a QInstance has having been validated.
Object used to record state of a QInstance having been validated.
Class that knows how to take a look at the data in a QInstance, and report
if it is all valid - e.g., non-null things are set; references line-up (e.g.,
a table's backend must be a defined backend).
Interface for additional / optional q instance validators.
Java
Access-Logger used for QJavalin handlers.
input to filter method (from javalin meta data), to decide if entry should be logged.
Types of log entries - useful for a filter (from javalin meta data).
methods for handling qqq API requests in javalin.
QQQ Javalin implementation.
MetaData specific to a QQQ Javalin server.
methods for handling qqq processes in javalin.
Interface for classes that can provide a list of endpoints to a javalin
server.
endpoints and handlers for deal with record scripts
Utility methods shared by javalin implementations
Definition of how 2 tables join together within a QQQ Instance.
Field Mapping implementation that uses string keys (e.g., from a CSV file
with a header row, or from one JSON object to the proper qqq field names)
QQQ abstraction over an AWS Lambda Request.
QQQ abstraction over an AWS Lambda Response.
Wrapper for
This class is responsible for loading a messaging provider, by its name, and
returning an instance.
Base class for qqq messaging-providers.
interface common among all objects that can be considered qqq meta data -
e.g., stored in a QInstance.
annotation to go on a QRecordEntity class, which you would like to be
processed by MetaDataProducerHelper, to automatically produce some meta-data
objects.
annotation to go on a PossibleValueEnum class, which you would like to be
processed by MetaDataProducerHelper, to automatically produce possible-value-
source meta-data based on the enum.
To avoid having secrets (passwords, access keys, etc) committed into meta data
files, as well as to just let some meta data not be hard-coded, this class is
used by the Enricher to "promote" values, such as ${env.ACCESS_KEY}
to be read from the environment (or other secret providers (to be implemented)).
javalin-handler that serves both rapidoc static html/css/js files, and
dynamically generated openapi json/yaml, for a given list of qqq middleware
versions
Exception thrown while doing module-dispatch
User-facing exception for when something wasn't found (e.g., a named table or
record-by-id).
Exception thrown if user doesn't have permission for an action
QQQ PicoCLI implementation.
An actual possible value - an id and label.
Meta-data to represent a "Possible value" - e.g., a translation of a foreign
key and/or a limited set of "possible values" for a field (e.g., from a foreign
table or an enum).
Possible types (e.g, kinds of data sources) for a possible value source.
Class responsible for looking up possible-values for fields/records and
make them into display values.
QQQ Utility Lambda to post input data to SQS.
When a process/function can't run because it's missing data, this interface
defines how the core framework goes back to a middleware (and possibly to a
frontend) to get the data.
Constructor for commonly used QProcessCallback's
Meta-Data to define a process in a QQQ instance.
base-class for bean-like classes to represent the fields of a process.
QRecord Entity for QQQProcess table - e.g., table that stores an id, name
and the label for all processes in the QQQ application.
Provides meta data for the QQQProcess table, PVS, and a cache table.
Utility class for accessing QQQProcess records (well, just their ids at this time)
Takes care of inserting upon a miss, and dealing with the cache table.
Object made available to scripts for access to qqq api (e.g., query, insert,
etc, plus object constructors).
QRecord Entity for QQQTable table - e.g., table that stores an id, name
and the label for all tables in the QQQ application.
Provides meta data for the QQQTable table, PVS, and a cache table.
Utility class for accessing QQQTable records (well, just their ids at this time)
Takes care of inserting upon a miss, and dealing with the cache table.
Full "filter" for a query - a list of criteria and order-bys
Class to help deduplicate redundant criteria in filters.
MetaData to define a message queue, which must exist within a QueueProvider.
Define a provider of queues (e.g., an MQ system, or SQS)
Data Record within qqq.
Methods for going back and forth from QRecords to API-versions of objects
Base class for entity beans that are interoperable with QRecords.
Reflective information about an association in a QRecordEntity
Reflective information about a field in a QRecordEntity
Base class for enums that are interoperable with QRecords.
Meta-Data to define how to view a qqq record list (e.g., what fields to show).
Class to convert QRecords to CSV Strings.
Utility methods for working with QRecords (and the values they contain)
Extension on QRecord, intended to be used where you've got records from
multiple tables, and you want to combine them into a single "wide" joined
record - but to do so without copying or modifying any of the individual
records.
Meta-data definition of a source of data for a report (e.g., a table and query
filter or custom-code reference).
Field within a report
Exception thrown while generating reports
Meta-data definition of a report generated by QQQ
Base class for unchecked exceptions thrown in qqq.
QQQ service to manage scheduled jobs, using 1 or more Schedulers - implementations
of the QSchedulerInterface
Meta-data to define scheduled actions within QQQ.
Define a type of security key (e.g., a field associated with values), that
can be used to control access to records and/or fields
QQQ Slack implementation.
Class to provide QQQ Standard table invalid input: '&' process actions via AWS Lambda.
A step for a state-machine flow based Process.
Abstract Base class for status messages (errors or warnings) that can be
attached to QRecords.
Meta-Data to define a step in a process in a QQQ instance.
Jackson custom deserialization class, to return an appropriate sub-type of
QTableBackendDetails, based on the backendType of the containing table.
Interface for actions that a backend can perform, based on streaming data
into the backend's storage.
Base-class for app-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for field-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for instance-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for process-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for table-level meta-data defined by some supplemental module, etc,
outside of qqq core
Special session, indicating that an action being executed is being done not
on behalf of a (human or otherwise) user - but instead, is the application/
system itself.
Details about how this table's record automations are set up.
Base class where backends can specify additional per-table meta-data.
Jackson custom deserialization class, to return an appropriate sub-type of
QTableBackendDetails, based on the backendType of the containing table.
Meta-Data to define a table in a QQQ instance.
Singleton to provide access between QQQ and the quartz Scheduler system.
Action to run a query against a table.
After running a query, if it's for a table that's a CacheOf another table,
see if there are any cache use-cases to apply to the query result.
Information about the query that an application (or qqq service) may know and
want to tell the backend, that can help influence how the backend processes
query.
Input data for the Query action
Todo - maybe make a class between AbstractTableActionInput and {QueryInput,
CountInput, and AggregateInput}, with common attributes for all of these
"read" operations (like, queryHints,
Interface for the Query action.
Part of query (or count, aggregate) input, to do a Join as part of a query.
define the types of joins - INNER, LEFT, RIGHT, or FULL.
Note that much of this class is/was ported (well, copied) to BaseRDBMSActionStrategy
around 2025-01, during the addition of SQLite backend module.
Common getters invalid input: '&' setters, shared by both QueryInput and GetInput.
Output for a query action
Process used by the saved bulkLoadProfile dialogs
Process used by the saved view dialogs
QRecord Entity for QueryStat table
QRecord Entity for QueryStatCriteriaField table
QRecord Entity for QueryStatJoinTable table
Singleton, which starts a thread, to store query stats into a table.
QRecord Entity for QueryStatOrderByField table
Utility for building a query string - taking care of things like:
- do I need the "?"
Help parse query strings into maps.
Types of queues supported by QQQ.
Model containing datastructure expected by frontend AWS quick sight widget
TODO: this might just be an IFrameChart widget in the future
AWS Quicksite specific meta data for frontend dashboard widget
Widget implementation for amazon QuickSight charts
Model a file that a user uploaded (or otherwise submitted to the qqq backend).
Exception with a good-quality message meant to be shown to an end-user.
Exception for when there's a problem with a value (like a string that you need
to be an integer, but it isn't).
Utility to apply display formats to values for records and fields.
Class to wrap warning messages to attach to QRecords.
Base class for the data returned by rendering a Widget.
Base metadata for frontend dashboard widgets
Interface for qqq widget meta data
Model containing datastructure expected by frontend bar raw html widget
Meta-data to provide details of an RDBMS backend (e.g., connection params)
QQQ Backend module for working with Relational Databases (RDBMS's).
Extension of QTableBackendDetails, with details specific to an RDBMS table.
note - this class is pretty mysql-specific
RDBMS implementation of backend transaction.
Only the fields which exist in the record's values map will be updated.
Base class for custom-codes to run as an automation action
Input data for the RecordAutomationHandler interface.
Utility class for updating the automation status data for records
Interface with utility methods that pre insert/update/delete customizers
may want to use.
Container for an old value and a new value.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducerHelper), to produce a QPossibleValueSource meta-data
based on a QRecordEntity class (which has corresponding QTableMetaData).
How are records stored in the files in a filesystem backend?
Generic widget to display a list of records.
Utility to help processes lookup records.
Object to connect a producer of records with a consumer.
Subclass of BufferedRecordPipe, which ultimately sends records down to an
original RecordPipe.
Define (for a table) a lock that applies to records in the table - e.g.,
a key type, and a field that has values for that key.
standard filtering operations for lists of record security locks.
Meta Data Producer for RedirectState table
Utilities for bean-like classes (e.g., QRecordEntity, QProcessPayload) that
use reflection to understand their bean-fields
Entity bean for the rendered report table
Process step to actually execute rendering a saved report.
define process for rendering saved reports!
initial backend-step before rendering a saved report.
API-Customizer for the RenderSavedReport process
Class that helps prepare the RenderSavedReport process for use in an API
api process output specifier for the RenderSavedReport process
Basic action to render a template!
Class for loading widget implementation code and rendering of widgets
Input data container for the RenderWidget action
Output for an Export action
Action to do a "replace" - e.g: Update rows with unique-key values that are
already in the table; insert rows whose unique keys weren't already in the
table, and delete rows that weren't in the input (all based on a
UniqueKey that's part of the input)
Note - the filter in the ReplaceInput - its role is to limit what rows are
potentially deleted.
single entry in ReportColumns object - as part of SavedReport
type of object expected to be in the SavedReport columnsJSON field
Interface to be implemented to do a custom source of data for a report
(instead of just a query against a table).
Member of report invalid input: '&' export Inputs, that wraps details about the destination of
where invalid input: '&' how the report (or export) is being written.
QQQ Report/export file formats
sub-set of ReportFormats to expose as possible-values in-apps
Input for a Report action
Output for a Report action
Utility for verifying that the RenderReports process works for all fields,
on all tables, and all exposed joins.
Types of reports that QQQ can generate
Note - exists under 2 names, for the RenderSavedReport process, and for the
ScheduledReport table (and can be used in your custom code too:
by default, in qqq backend core, we'll assume this widget is being used on the
view screen for a ScheduledReport, with field names that we know from that table.
Interface for customizer on a QReportView.
Management process to reschedule all scheduled jobs (in all schedulers).
Manage process to resume all quartz jobs
interface used by QJavalinRouteProviderInterface subclasses, to interact with
QQQ Authentication modules, to provide authentication to custom javalin routes.
Action handler for running backend steps as part of processes.
Input data container for the RunBackendStep action
Output data container for the RunBackendStep action
Action handler for running q-processes (which are a sequence of q-steps).
Input data container for the RunProcess action
Output data container for the RunProcess action
Extract step for the run-record process.
Load step for the runRecordScript process - runs the script on a page of records
Transform step run-record-script process.
Definition for Basic process to run a report.
define process for rendering scheduled reports - that is - a thin layer on
top of rendering a saved report.
Process to manually run table automations, for a table.
S3 backend meta data.
QQQ Backend module for working with AWS S3 filesystems
(mass, streamed) storage action for s3 module
S3 specific Extension of QTableBackendDetails
OutputStream implementation that knows how to stream data into a new S3 file.
Utility methods for working with AWS S3.
Meta Data Producer for SampleBarChart
Meta Data Producer for SampleStatisticsWidget
Meta Data Producer for SampleHTMLWidget
Meta Data Producer for SampleJavalin
Meta Data Producer for SampleLineChartWidget
Testing backend step - just sleeps however long you ask it to (or, throws if
you don't provide a number of seconds to sleep).
Testing backend step - just throws an exception after however long you ask it to sleep.
Meta Data Producer for SampleMultiStatisticsWidget
Meta Data Producer for SamplePieChart
Meta Data Producer for SampleSmallLineChartWidget
Meta Data Producer for SamplePieChart
Meta Data Producer for SampleStatisticsWidget
Meta Data Producer for SampleStepperWidget
Meta Data Producer for SampleStatisticsWidget
Meta Data Producer for SampleWidgetsDashboard
Entity bean for the savedBulkLoadProfile table
Entity bean for the saved report table
Utility for verifying that the RenderReports process works for all report
records stored in the saved reports table.
GenerateReportAction takes in ReportMetaData.
Entity bean for the saved filter table
Unique identifier for a thing that can be scheduled
Factory to produce SchedulableIdentity objects
Schedulable process runner - e.g., how a QProcess is run by a scheduler.
Interface for different types of schedulabe things that can be run
Schedulable SQSQueue runner - e.g., how an SQSQueuePoller is run by a scheduler.
Schedulable TableAutomations runner - e.g., how a table automations are run
by a scheduler.
Management process to schedule all new scheduled jobs (in all schedulers).
enum of core schedulable types that QQQ schedule manager directly knows about.
Entity bean for the scheduled report table
Utility methods used by various schedulers.
This class facilitates generating OpenAPI Schema objects based on reflectively
reading classes and annotations
ScriptTypeFileMode - possible value enum
Class responsible for looking up possible-values for fields/records and
make them into display values.
record to store "computed" values as part of a possible-value search -
e.g., ids type-convered, and lower-cased labels.
Input for the Search possible value source action
Output for the Search possible value source action
Utility class for working with AWS Secrets Manager.
Factory class for creating "standard" qfield sections.
SFTP backend meta data.
QQQ Backend module for working with SFTP filesystems (as a client)
(mass, streamed) storage action for sftp module
SFTP specific Extension of QTableBackendDetails
action for testing credentials for an SFTP backend connection
As a component of a ShareableTableMetaData instance, define details about
one particular audience type.
meta data to attach to a table, to describe that its records are shareable.
utility methods shared by s3 invalid input: '&' local-filesystem utils classes
Entity bean for the shared saved bulk load profile table
Entity bean for the shared saved report table
Entity bean for the shared saved view table
for a shared record, what scope of access is given.
Simple connection provider - no pooling, just opens a new connection for
every request.
javalin route provider that hosts a path in the http server via a path on
the file system
simple implementation of a route authenticator.
QQQ Service (Singleton) that starts up repeating, scheduled jobs within QQQ.
Utility methods to help with sleeping!
interface for meta data objects that may have come from a qbit, and where we
might want to get data about that qbit (e.g., config or meta-data).
Meta-data to provide details of an SQLite backend (e.g., path to the database file)
SQLite specialization of the default RDBMS/JDBC action strategy
settings that can be applied to either an SQSQueue or an SQSQueueProvider,
to control what the SQSQueuePoller does when it receives from AWS.
SQS subclass of meta-data for a specific Queue
Class to poll an SQS queue, and run process code for each message found.
Meta-data for an source of Amazon SQS queues (e.g, an aws account/credential
set, with a common base URL).
Helper for working with process summary lines
Standard class ran by SimpleScheduler.
Helper to cancel statements that timeout.
QQQ state provider interface.
Possible types of states to be stored.
Model containing datastructure expected by frontend statistics widget
Simple status enum - initially for statuses in process status lines.
Model containing datastructure expected by frontend stepper widget
Action to do (generally, "mass") storage operations in a backend.
Input for Storage actions.
Action to store a new version of a script, associated with a record.
Process used by the saved bulkLoadProfile dialog
Process used by the saved view dialog
Implementation of a code execution logger that logs into scriptLog and scriptLogLine
tables - e.g., as defined in ScriptMetaDataProvider.
Action to store a new version (revision) of a script.
Subclass of RunBackendStepInput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a page at a time -- so this class
overrides the getRecords and setRecords method, to just work with that page.
Subclass of RunBackendStepOutput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a page at a time -- so this class
overrides the getRecords and setRecords method, to just work with that page.
Backend step to do a streamed ETL
Backend step to do the execute portion of a streamed ETL job.
Extension to the base StreamedETLBackendStep, unique for where the source
table is a filesystem, where we want/need to collect the filenames that were
processed in the Extract step, so they can be passed into the cleanup step.
Backend step to do a preview of a full streamed ETL job
Definition for Streamed ETL process.
Backend step to do a full validation of a streamed ETL job
Definition for Streamed ETL process that includes a frontend.
Write excel formatted XML to a Writer.
String version of data aggregator
Utility methods for working with Strings
For a summary report, a list of field/value pairs that make up a "key".
Record error message for when the system was at fault - not the user.
Implementation of a code execution logger that logs to System.out and
System.err (for exceptions)
Definition of a specific action to run against a table
Meta-data to provide details of an Auth0 Authentication module
Common interface used by all (core) TableCustomizer types (e.g., post-query,
and {pre,post}-{insert,update,delete}.
Enum definition of possible table customizers - "roles" for custom code that
can be applied to tables.
Model containing datastructure expected by frontend bar chart widget
Action to fetch meta-data for a table.
Input for meta-data for a table.
Output for a table-metaData action
possible-value source provider for the `Tables` PVS - a list of all tables
in an application/qInstance.
Definition for Standard process to sync data from one table into another.
Definition of in-app/user/data-defined triggers (aka, automations).
State provider that uses files in the /tmp/ directory.
Interface to be implemented by script-running actions, if they want to allow
themselves to be used for user-testing of their script.
Action to test a script!
Helper to cancel statements that timeout.
Object to help track performance/runtime of codes.
Interface for meta-data classes that can be added directly (e.g, at the top
level) to a QInstance (such as a QTableMetaData - not a QFieldMetaData).
Mark a class as eligible for running through the SchemaBuilder.
Version of a map that uses a transformation function on keys.
Possible events that can trigger a record automation.
Lock thrown by ProcessLockUtils when you can't get the lock.
Definition of a Unique Key (or "Constraint", if you wanna use fancy words)
on a QTable.
Methods to help with unique key checks.
To make a list of unique key values here behave like they do in an RDBMS
(which is what we're trying to mimic - which is - 2 null values in a field
aren't considered the same, so they don't violate a unique key) (at least, that's
how some RDBMS's work, right??)
Management process to unschedule all scheduled jobs (in all schedulers).
Action to update one or more records.
Helper for backends that want to do their updates on records grouped by the
set of fields that are being changed, and/or by the values those fields are
being set to.
Input data handler for the update action
Interface for the update action.
Output for an update action
QRecord Entity for UserSession table
Meta Data Producer for UserSession
Model containing datastructure expected by frontend USA map
Generic widget for display a map of the us
Utility class to apply value behaviors to records.
Validate the min invalid input: '&' max value for numeric fields.
Behaviors for string fields, if their value is too long.
Utilities work values - e.g., type-cast-like operations
see https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
Field behavior that changes the whitespace of string values.
use a flatter mapping object, where field names look like:
associationChain.fieldName,index.subIndex
Details about dropdown fields on a widget
Possible types for widget dropdowns
Possible values for widget type