OpenEdge.DataAdmin.Lang.QueryString

Namespace:

OpenEdge.DataAdmin.Lang

Type: Class

QueryString

Parent Classes:

Progress.Lang.Object

OpenEdge.DataAdmin.Lang.QueryString

Inherits:

Progress.Lang.Object

	CLASS QueryString HD
	Purpose Manage query string tranformation and manipulation.
	String based, need no handles or compilation.
	Manages a query string with field expressions and allows a caller
	to add these expressions to the correct tables in an existing query.
	The main purpose is to support query transformation from a query
	with field expressions against a domain table to a query expressed
	against physical tables.
	The mapping and transformation is optionally triggered by
	passing an object that implements IQueryMap as the second parameter.
	Parameters: pcQueryWhere complete query expression
	pQueryMap optional IQueryMap (columnSource, defaultQuery)
	Notes: This is a copied subset of ADM2's query manipulation with
	additional parsing.
	- The BaseQuery are important for transformation, but can also
	be used provide table options to the main query when used with no tranformation.
	(and workaround the lack of full query parsing)
	- The passed pcQueryWhere could fail with too complex queries ...
	There is still an attempt to handle anything by just giving up and
	treat complex expressions as a single expression while the
	transformation continues.. . If it fails with expressions on
	functions with parenthesis try to add a parenthesis around
	functions that also have parenthesis (no promise..) or fix the code.
	- The passed query is expected to be a working (compilable) dynamic
	temp-table query with no database options like locking. Outer
	joins would not make sense in this context either.
	- It is crucial that all values are quoted to be correctly parsed,
	(also needed to handle non american numeric and date formats,
	assuming same session format settings here as when applied)
	- The transformation can split the expressions on different tables
	if they are using an AND operator. An expression against multiple
	tables with an OR operator between them will be added to the query
	entry of the last of the tables.
	- Allthough some of the code is based on the ADM, it is still meant
	as sample of query manipulation.
	There are alternatives to full parsing.
	The query syntax is after all is a subset of the ABL programming
	language. Maybe reconsider the design to see if some of the
	complexity could be better encapsulated in the data access or data
	source object. Even if this logic expects the query to be in
	compilable form it is not really necessary at this stage, so tokens
	and special patterns could be used to ease the
	transformation/mapping.

Options

Name

Purpose

AddExpression (character)

AddFilter (character, character, character)

AddFilter (log[], character[], character[], character[])

CHARACTER BufferWhereClause (character, character, integer)

CHARACTER BuildDefaultQueryString (character)

Return a default query from data (no table options) ------------------------------------------------------------------------------*/

CHARACTER BuildFindString (character)

/* untested and doesn't do anything that you could not do with buildQueryString */

CHARACTER BuildFindString (character, character)

/* untested and doesn't do anything that you could not do with buildQueryString */

CHARACTER BuildFindString (handle)

CHARACTER BuildParsedQueryString (character)

CHARACTER BuildQueryString ()

CHARACTER BuildQueryString (character)

CHARACTER BuildQueryString (handle)

CHARACTER BuildSortExpression (character)

/* return sort only for specified tables */

LOGICAL CanAddRefTables (character, integer, character)

CHARACTER CheckIndex (handle)

ClearFilter ()

ClearQuery ()

CHARACTER GetCased (character)

CHARACTER GetEvaluation (integer)

CHARACTER GetEvaluationTables (integer, character)

CHARACTER GetParsedQueryTables ()

CHARACTER GetTableEvaluation (integer, integer, character)

CHARACTER GetTableExpression (character)

CHARACTER GetUnparsedWhereClause (character)

/** get the buffer where clause from the unparsed query ..*/

CHARACTER InsertExpression (character, character, character)

CHARACTER InsertString (character, character, integer, integer)

/* workaround for temporary core bug */

LOGICAL InsertToQuery (handle)

/* insert the querystring into the query - uses mQueryRef IQueryMap:BaseQuery if unprepared - buffers decide the order (can be different than BaseQuery )*/

CHARACTER MaskQuotes (character, character)

Utility function that masks all quoted strings in the passed string Parameters: pcString = string that might have embedded quoted strings. must be syntactically correct - paired single or double. pcReplaceChar = single char to insert in quoted positions.

CHARACTER MergeQueryString (character, character)

CHARACTER NewQuerySort (character, character)

ParseQuery (character)

ParseSortExpression (character)

CHARACTER ResolveColumn (character, integer)

SetQueryString (character)

/* set querystring */

SetSort (character)

/* ParseSortExpression will transform and set SortExpression property, which has a protected set */

Showdata ()

CHARACTER TableEvaluation (integer, character)

CHARACTER WhereClauseBuffer (character)

Options

Name

Purpose

QueryString ()

/* use as utility - InsertExpression */

QueryString (character)

/* queryWhere is a simple query without any table options like no-lock */

QueryString (character, character)

/* QueryWhere - is a simple query without any table options like no-lock can have query options like indexed-reposition Basequery - query to which the QueryWhere and filters should be merged - provide table options as well as a fixed expressions - uses BuildDefaultQuery if base query is blank or ? */

QueryString (character, IQueryMap)

/* queryWhere is a simple query without any table options like no-lock Basequery */

QueryString (IQueryMap)

Options

Name

Purpose

CHARACTER BaseQuery

LOGICAL MergeQuery

CHARACTER QueryOptions

CHARACTER SortExpression

CHARACTER Statement

CHARACTER Tables

LOGICAL UpperCaseKeyWords