1844 lines
90 KiB
Plaintext
1844 lines
90 KiB
Plaintext
Function SQL_Services(@Service, @Params)
|
|
/***********************************************************************************************************************
|
|
|
|
This program is proprietary and is not to be used by or disclosed to others, nor is it to be copied without written
|
|
permission from SRP Computer Solutions, Inc.
|
|
|
|
Name : SQL_Services
|
|
|
|
Description : Handler program for all module related services.
|
|
|
|
Notes : The generic parameters should contain all the necessary information to process the services. Often
|
|
this will be information like the data Record and Key ID.
|
|
|
|
Parameters :
|
|
Service [in] -- Name of the service being requested
|
|
Param1-10 [in/out] -- Additional request parameter holders
|
|
Response [out] -- Response to be sent back to the Controller (MCP) or requesting procedure
|
|
|
|
Metadata :
|
|
|
|
History : (Date, Initials, Notes)
|
|
08/13/18 dmb Original programmer.
|
|
|
|
***********************************************************************************************************************/
|
|
|
|
#pragma precomp SRP_PreCompiler
|
|
|
|
$insert LOGICAL
|
|
$insert SERVICE_SETUP
|
|
$insert MICROSOFT_ADO_EQUATES
|
|
$insert DICT_EQUATES
|
|
|
|
Declare function Memory_Services, SQL_Services, Database_Services, SRP_JSON, SRP_Array, SRP_Hash, SRP_COM, Logging_Services
|
|
Declare subroutine Memory_Services, SQL_Services, Database_Services, SRP_JSON, SRP_Stopwatch, SRP_COM, Logging_Services,Sleepery
|
|
|
|
GoToService else
|
|
Error_Services('Add', Service : ' is not a valid service request within the ' : ServiceModule : ' module.')
|
|
end
|
|
|
|
Return Response OR ''
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Service Parameter Options
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
Options BOOLEAN = True$, False$
|
|
Options ProviderTypes = 'ODBC', 'SQLNCLI11'
|
|
Options Servers = 'mesirwdb002.irworld.irf.com', '10.95.128.28\PROD1,53959', 'messa03ec.ec.local'
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Services
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// WriteDataRowToSQL
|
|
//
|
|
// High level services that writes OpenInsight data into a designated SQL table. This services calls other lower
|
|
// level services as needed and assumes an OpenInsight to SQL map has already been created.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service WriteDataRowToSQL(OITableName, OIKeyID, OIRow, OIColumns)
|
|
|
|
If (OITableName NE '') AND (OIKeyID NE '') AND (OIRow NE '') then
|
|
// Create a new or get an existing Connection Object.
|
|
SQLServer = SQL_Services('GetSQLServer', OITableName)
|
|
objConnection = SQL_Services('GetConnectionObject', SQLServer, 2)
|
|
|
|
If Error_Services('NoError') then
|
|
// Set up transaction processing, initiate SQL queries, and commit the transaction.
|
|
TransactionQueries = ''
|
|
* TransactionQueries := "SET TRANSACTION NAME 'oi'" : @FM
|
|
|
|
// Create the DELETE statements so the data in SQL is cleared out first.
|
|
* TransactionQueries := SQL_Services('GetSQLDeleteStatements', OITableName, OIKeyID, OIRow) : @FM
|
|
|
|
// Create the INSERT statements to store the data in SQL.
|
|
TransactionQueries := SQL_Services('GetSQLInsertStatements', OITableName, OIKeyID, OIRow, OIColumns) : @FM
|
|
|
|
// End transaction processing.
|
|
* TransactionQueries := 'COMMIT' : @FM
|
|
|
|
TransactionQueries[-1, 1] = ''
|
|
end
|
|
|
|
If Error_Services('NoError') then
|
|
// Process the tranaction queries.
|
|
SQL_Services('ExecuteQueries', objConnection, TransactionQueries)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The OITableName, OIKeyID, or OIRow argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// DeleteDataRowFromSQL
|
|
//
|
|
// High level services that deletes data from a designated SQL table. This services calls other lower level services as
|
|
// needed and assumes an OpenInsight to SQL map has already been created.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service DeleteDataRowFromSQL(OITableName, OIKeyID)
|
|
|
|
If (OITableName NE '') AND (OIKeyID NE '') then
|
|
// Create a new or get an existing Connection Object.
|
|
SQLServer = SQL_Services('GetSQLServer', OITableName)
|
|
objConnection = SQL_Services('GetConnectionObject', SQLServer, 2)
|
|
|
|
If Error_Services('NoError') then
|
|
// Set up transaction processing, initiate SQL queries, and commit the transaction.
|
|
TransactionQueries = ''
|
|
TransactionQueries := "SET TRANSACTION NAME 'oi'" : @FM
|
|
|
|
// Create the DELETE statements so the data in SQL is cleared out first.
|
|
TransactionQueries := SQL_Services('GetSQLDeleteStatements', OITableName, OIKeyID) : @FM
|
|
|
|
// End transaction processing.
|
|
TransactionQueries := 'COMMIT' : @FM
|
|
|
|
TransactionQueries[-1, 1] = ''
|
|
end
|
|
|
|
If Error_Services('NoError') then
|
|
// Process the tranaction queries.
|
|
SQL_Services('ExecuteQueries', objConnection, TransactionQueries)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The OITableName or OIKeyID argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// ReadDataRowFromSQL
|
|
//
|
|
// High level services that reads data from a designated SQL table. This services calls other lower level services as
|
|
// needed and assumes an OpenInsight to SQL map has already been created.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service ReadDataRowFromSQL(OITableName, OIKeyID)
|
|
|
|
OIRow = ''
|
|
|
|
If (OITableName NE '') AND (OIKeyID NE '') then
|
|
// Create a new or get an existing Connection Object.
|
|
SQLServer = SQL_Services('GetSQLServer', OITableName)
|
|
objConnection = SQL_Services('GetConnectionObject', SQLServer, 2)
|
|
|
|
If Error_Services('NoError') then
|
|
// Select the SQL data for the primary SQL table associated to the OpenInsight table.
|
|
SQLTableName = SQL_Services('GetPrimarySQLTable', OITableName)
|
|
SQLSelectStatement = SQL_Services('GetSQLSelectStatement', OITableName, SQLTableName, OIKeyID)
|
|
SQLData = SQL_Services('ExecuteQuery', objConnection, SQLSelectStatement, True$)
|
|
If (SQLData NE '') AND (Error_Services('NoError')) then
|
|
OIRow = SQL_Services('GetMappedOIColumnValues', OITableName, SQLTableName, SQLData)
|
|
end
|
|
end
|
|
|
|
If Error_Services('NoError') then
|
|
// Select the SQL data for all secondary SQL tables associated to the OpenInsight table.
|
|
SQLTableNames = SQL_Services('GetSecondarySQLTables', OITableName)
|
|
If SQLTableNames NE '' then
|
|
For Each SQLTableName in SQLTableNames using @FM
|
|
SQLSelectStatement = SQL_Services('GetSQLSelectStatement', OITableName, SQLTableName, OIKeyID)
|
|
// Create a new or get an existing Connection Object.
|
|
SQLServer = SQL_Services('GetSQLServer', OITableName)
|
|
objConnection = SQL_Services('GetConnectionObject', SQLServer, 2)
|
|
|
|
If Error_Services('NoError') then
|
|
SQLData = SQL_Services('ExecuteQuery', objConnection, SQLSelectStatement, True$)
|
|
If (SQLData NE '') AND (Error_Services('NoError')) then
|
|
OIRow = SQL_Services('GetMappedOIColumnValues', OITableName, SQLTableName, SQLData, OIRow)
|
|
end
|
|
end
|
|
While (Error_Services('NoError'))
|
|
Next SQLTable
|
|
end
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The OITableName or OIKeyID argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = OIRow
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetRowCount
|
|
//
|
|
// Server - Name of the server the connection object is bound to. This should be the same name that
|
|
// will be used in the Data Source connection string.
|
|
// TableName - Database Table whose row count is being requested.
|
|
//
|
|
// High level services that counts the number of rows in a designated table. This services calls other lower level
|
|
// services.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetRowCount(Server=Servers, TableName)
|
|
|
|
RowCount = ''
|
|
|
|
If (Server NE '') AND (TableName NE '') then
|
|
// Create a new or get an existing Connection Object.
|
|
objConnection = SQL_Services('GetConnectionObject', Server, 2)
|
|
|
|
If Error_Services('NoError') then
|
|
// Select the SQL data for the primary SQL table associated to the OpenInsight table.
|
|
ErrorMessage = ''
|
|
SQLCountStatement = 'SELECT COUNT(*) FROM ' : TableName
|
|
RowCount = SQL_Services('ExecuteQuery', objConnection, SQLCountStatement, True$)
|
|
If Error_Services('HasError') then
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
end
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
If ErrorMessage NE '' then Error_Services('Add', ErrorMessage)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The Server or TableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = RowCount
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetDataRows
|
|
//
|
|
// Server - Name of the server the connection object is bound to. This should be the same name that
|
|
// will be used in the Data Source connection string.
|
|
// QueryStatement - Query command. This should be a properly syntaxed SQL statement.
|
|
//
|
|
// High level service that gets database rows from the indicated database using the indicated query statement. This
|
|
// service will automatically get the connection and query object needed to perform the query statement.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetDataRows(Server=Servers, QueryStatement)
|
|
|
|
DataRows = ''
|
|
|
|
If (Server NE '') AND (QueryStatement NE '') then
|
|
ErrorMessage = ''
|
|
objConnection = SQL_Services('GetConnectionObject', Server, 2)
|
|
If Error_Services('NoError') then
|
|
If Error_Services('NoError') then
|
|
DataRows = SQL_Services('ExecuteQuery', objConnection, QueryStatement, True$)
|
|
end
|
|
// Get any errors from the GetConnectionObject service or the ExecuteQuery service.
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
end
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
If ErrorMessage then Error_Services('Set', ErrorMessage)
|
|
end else
|
|
Error_Services('Add', 'Server or QueryStatement argument was missing in the ' : Service : 'service.')
|
|
end
|
|
|
|
Response = DataRows
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetConnectionObject
|
|
//
|
|
// Server - Name of the server the connection object is bound to. This should be the same name that
|
|
// will be used in the Data Source connection string.
|
|
// AttemptsBeforeFailure - Number of attempts to make the connect before erroring out. Default is 1.
|
|
//
|
|
// Returns a Connection Object based on the server. A returned Connection Object means that the server has been
|
|
// successfully connected to with the provided credentials. This service uses caching, so until an existing Connection
|
|
// Object has been destroyed (see the DestroyConnectionObject service), it will continue to use the one already in
|
|
// existence.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetConnectionObject(Server=Servers, AttemptsBeforeFailure)
|
|
|
|
If AttemptsBeforeFailure EQ '' then
|
|
AttemptsBeforeFailure = 1
|
|
OpenConnectionAttempts = 1
|
|
end else
|
|
OpenConnectionAttempts = AttemptsBeforeFailure
|
|
end
|
|
|
|
objConnection = ''
|
|
|
|
// Check to see if the Connection Object already exists.
|
|
ServiceKeyID := '*' : Server
|
|
objConnection = Memory_Services('GetValue', ServiceKeyID)
|
|
If objConnection EQ '' then
|
|
If Server NE '' then
|
|
Attempts = 0
|
|
Error = ''
|
|
Loop
|
|
If SRP_COM(objConnection, 'CREATE', 'ADODB.Connection') then
|
|
Memory_Services('SetValue', objConnection : '*Server', Server)
|
|
If SRP_COM('', 'ERROR') then
|
|
Error = SRP_COM('', 'ERROR')
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
objConnection = ''
|
|
end else
|
|
ConnectionString = SQL_Services('GetConnectionString', Server)
|
|
If Error_Services('NoError') then
|
|
OpenAttempts = 0
|
|
Loop
|
|
SRP_COM(objConnection, 'CALL', 'Open', ConnectionString)
|
|
HasConnectionError = SQL_Services('HasConnectionObjectErrors', objConnection)
|
|
If (HasConnectionError) and (OpenAttempts GE AttemptsBeforeFailure) then
|
|
*Error = SQL_Services('GetConnectionObjectErrors', objConnection)
|
|
// Retrieval of errors has been temporarily disabled due to an issue where
|
|
// we are receiving over one million errors, which is causing the OENGINES to hang.
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
objConnection = ''
|
|
end
|
|
OpenAttempts += 1
|
|
Until (objConnection NE '') OR (OpenAttempts GE AttemptsBeforeFailure)
|
|
Repeat
|
|
end
|
|
end
|
|
end
|
|
Attempts += 1
|
|
Until (objConnection NE '') OR (Attempts GE AttemptsBeforeFailure)
|
|
Repeat
|
|
If objConnection then
|
|
Memory_Services('SetValue', ServiceKeyID, objConnection)
|
|
end else
|
|
Error_Services('Add', 'Unable to create the connection object to ' : Server : ' in the ' : Service : ' service: ' : Error)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'Server argument was missing from the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = objConnection
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// DestroyConnectionObject
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Destroys the Connection Object. This returns True$ if successful, False$ if not.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service DestroyConnectionObject(objConnection)
|
|
|
|
Destroyed = False$ ; // Assume object is not destroyed for now.
|
|
|
|
If objConnection NE '' then
|
|
Error = ''
|
|
// Close the connection object, but don't worry about errors. It might have already been closed.
|
|
SRP_COM(objConnection, 'CALL', 'Close')
|
|
SRP_COM(objConnection, 'RELEASE')
|
|
If SRP_COM('', 'ERROR') then
|
|
Error = SRP_COM('', 'ERROR')
|
|
end else
|
|
Destroyed = True$
|
|
end
|
|
If Destroyed then
|
|
SQL_Services('ClearConnectionErrors', objConnection)
|
|
Server = Memory_Services('GetValue', objConnection : '*Server')
|
|
Memory_Services('SetValue', ServiceModule : '*GetConnectionObject*' : Server, '')
|
|
end else
|
|
SQL_Services('AddConnectionErrors', objConnection, Error)
|
|
Error_Services('Add', 'Service : ' : Service : ', Error : ' : Error)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = Destroyed
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// HasConnectionObjectErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Returns a Boolean flag indicating if the Connection Object has any connection errors.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service HasConnectionObjectErrors(objConnection)
|
|
|
|
HasConnectionObjectErrors = False$ ; // Assume false for now.
|
|
|
|
If objConnection NE '' then
|
|
objErrors = SRP_COM(objConnection, 'GET', 'Errors')
|
|
NumErrors = SRP_COM(objErrors, 'GET', 'Count')
|
|
If NumErrors GT 0 then HasConnectionObjectErrors = True$
|
|
SRP_COM(objErrors, 'RELEASE')
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = HasConnectionObjectErrors
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetConnectionObjectErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Returns a string of errors errors associated with the indicated Connection Object. Different error properties related
|
|
// to the same error object will be surrounded by square braces. Different error oejcts will be separated by a
|
|
// semi-colon.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetConnectionObjectErrors(objConnection)
|
|
|
|
ConnectionObjectErrors = ''
|
|
|
|
If objConnection NE '' then
|
|
objErrors = SRP_COM(objConnection, 'GET', 'Errors')
|
|
NumErrors = SRP_COM(objErrors, 'GET', 'Count')
|
|
If NumErrors GT 0 then
|
|
For ErrorCnt = 1 to NumErrors
|
|
objError = SRP_COM(objErrors, 'GET', 'Item', ErrorCnt - 1)
|
|
ErrorDescription = SRP_COM(objError, 'GET', 'Description')
|
|
If ErrorDescription NE 0 then
|
|
ConnectionObjectErrors := '[' : ErrorDescription : ']'
|
|
ConnectionObjectErrors := '[' : SRP_COM(objError, 'GET', 'NativeError') : ']'
|
|
ConnectionObjectErrors := '[' : SRP_COM(objError, 'GET', 'Number') : ']'
|
|
ConnectionObjectErrors := '[' : SRP_COM(objError, 'GET', 'Source') : ']'
|
|
ConnectionObjectErrors := '[' : SRP_COM(objError, 'GET', 'SQLState') : ']'
|
|
ConnectionObjectErrors := ';'
|
|
end
|
|
SRP_COM(objError, 'RELEASE')
|
|
Next ErrorCnt
|
|
end
|
|
SRP_COM(objErrors, 'RELEASE')
|
|
ConnectionObjectErrors[-1, 1] = ''
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = ConnectionObjectErrors
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// AddConnectionErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
// Errors - @FM delimited list of errors.
|
|
//
|
|
// Adds a list of errors to the indicated Connection Object so the GetConnectionErrors service can retrieve them at
|
|
// will. This list will accumulate until the ClearConnectionErrors service is called.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service AddConnectionErrors(objConnection, Errors)
|
|
|
|
objConnection = objConnection[1, '*']
|
|
ServiceKeyID = ServiceModule : '*' : 'GetConnectionErrors' : '*' : objConnection
|
|
ConnectionErrors = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If (objConnection NE '') AND (Errors NE '') then
|
|
If ConnectionErrors NE '' then
|
|
ConnectionErrors := @FM : Errors
|
|
end else
|
|
ConnectionErrors = Errors
|
|
end
|
|
Memory_Services('SetValue', ServiceKeyID, ConnectionErrors)
|
|
end else
|
|
Error_Services('Add', 'The objConnection or Errors argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetConnectionErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Returns an @FM list of all connection errors associated with the indicated Connection Object.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetConnectionErrors(objConnection)
|
|
|
|
objConnection = objConnection[1, '*']
|
|
ConnectionErrors = ''
|
|
|
|
If objConnection NE '' then
|
|
ServiceKeyID = ServiceModule : '*' : 'GetConnectionErrors' : '*' : objConnection
|
|
ConnectionErrors = Memory_Services('GetValue', ServiceKeyID)
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = ConnectionErrors
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// ClearConnectionErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Clears all connection errors associated with the indicated Connection Object.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service ClearConnectionErrors(objConnection)
|
|
|
|
objConnection = objConnection[1, '*']
|
|
|
|
If objConnection NE '' then
|
|
ServiceKeyID = ServiceModule : '*' : 'GetConnectionErrors' : '*' : objConnection
|
|
Memory_Services('SetValue', ServiceKeyID, '')
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// HasConnectionErrors
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Returns a Boolean flag indicating of the Connection Object has any connection errors.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service HasConnectionErrors(objConnection)
|
|
|
|
objConnection = objConnection[1, '*']
|
|
HasErrors = False$ ; // Assume no errors for now.
|
|
|
|
If objConnection NE '' then
|
|
ConnectionErrors = SQL_Services('GetConnectionErrors', objConnection)
|
|
If ConnectionErrors NE '' then
|
|
HasErrors = True$
|
|
end else
|
|
HasErrors = False$
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The objConnection argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = HasErrors
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetConnectionString
|
|
//
|
|
// Returns a well formed Connection String for the current server. This is used for ADO connections.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetConnectionString(Server)
|
|
|
|
ServiceKeyID := '*' : Server
|
|
ConnectionString = Memory_Services('GetValue', ServiceKeyID)
|
|
If ConnectionString EQ '' then
|
|
If (Server NE '') then
|
|
ConnectionInfo = Database_Services('ReadDataRow', 'APP_INFO', 'SQL_SERVER*' : Server)
|
|
If ConnectionInfo NE '' then
|
|
ConnectionString = ConnectionInfo
|
|
Convert @FM to ';' in ConnectionString
|
|
ConnectionString := ';'
|
|
Memory_Services('SetValue', ServiceKeyID, ConnectionString)
|
|
end else
|
|
Error_Services('Add', Server : ' is not a valid server. [' : Service : ']')
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The Server argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = ConnectionString
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// ExecuteQuery
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
// QueryStatement - Query command. This should be a properly syntaxed SQL statement.
|
|
// ReturnDataRows - Boolean flag to determine if all data rows resulting from the query should automatically be
|
|
// returned. This is the same as if the caller used the GetAllQueryDataRows service, but this allows
|
|
// everything to be done in one service rather than two. Default is False$
|
|
//
|
|
// Executes the query against the Connection Object. If the ReturnDataRows argument is False$, then this returns True$
|
|
// if there are results, False$ if there are no results or if there is a problem running the services. Otherwise, the
|
|
// datarows from the query will be returned unless there is an error.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service ExecuteQuery(objConnection, QueryStatement, ReturnDataRows)
|
|
|
|
Results = False$ ; // Assume no results from this query for now.
|
|
If ReturnDataRows NE True$ then ReturnDataRows = False$
|
|
If (objConnection NE '') AND (QueryStatement NE '') then
|
|
objRecordSet = SRP_COM(objConnection, 'CALL', 'Execute', QueryStatement)
|
|
If SRP_COM('', 'HASERROR') then
|
|
* If SQL_Services('HasConnectionObjectErrors', objConnection) then
|
|
Error = SQL_Services('GetConnectionObjectErrors', objConnection)
|
|
Error2 = SRP_COM('', 'ERROR')
|
|
Error_Services('Add', 'ADO error in the ' : Service : ' service: ' : Error)
|
|
Results = '' ; // Since there is an error, no result should be returned.
|
|
end else
|
|
If ReturnDataRows then
|
|
Results = SQL_Services('GetAllQueryDataRows', objRecordSet, objConnection)
|
|
If Error_Services('HasError') then
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
End
|
|
end else
|
|
Results = True$
|
|
end
|
|
end
|
|
SRP_COM(objRecordSet, 'CALL', 'Cancel')
|
|
SRP_COM(objRecordSet, 'RELEASE')
|
|
end else
|
|
Error_Services('Add', 'The objConnection or QueryStatement argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = Results
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// ExecuteQueries
|
|
//
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
// QueryStatements - @FM delimited list of Query commands. These should be a properly syntaxed SQL statement.
|
|
//
|
|
// Executes one or more queries against the Connection Object. This returns True$ if all queries processed without any
|
|
// errors, False$ if there is a problem running any of the queries.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service ExecuteQueries(objConnection, QueryStatements)
|
|
|
|
AllAccepted = True$ ; // Assume all queries were accepted for now unless otherwise proven.
|
|
|
|
If (objConnection NE '') AND (QueryStatements NE '') then
|
|
For Each QueryStatement in QueryStatements using @FM
|
|
objRecordSet = SRP_COM(objConnection, 'CALL', 'Execute', QueryStatement)
|
|
If SQL_Services('HasConnectionObjectErrors', objConnection) then
|
|
Error = SQL_Services('GetConnectionObjectErrors', objConnection)
|
|
Error_Services('Add', 'ADO error in the ' : Service : ' service: ' : Error)
|
|
AllAccepted = False$
|
|
end
|
|
SRP_COM(objRecordSet, 'CALL', 'Cancel')
|
|
SRP_COM(objRecordSet, 'RELEASE')
|
|
Until Not(AllAccepted)
|
|
Next QueryStatement
|
|
end else
|
|
AllAccepted = False$
|
|
Error_Services('Add', 'The objConnection or QueryStatement argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = AllAccepted
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetAllQueryDataRows
|
|
//
|
|
// objRecordSet - RecordSet Object (see ExecuteQuery service.)
|
|
// objConnection - Connection Object (see GetConnectionObject service.)
|
|
//
|
|
// Gets all of the data rows from the RecordSet Object. This returns an @RM array of data rows.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetAllQueryDataRows(objRecordSet, objConnection)
|
|
|
|
DataRows = ''
|
|
TableName = ''
|
|
Error = ''
|
|
If objRecordSet NE '' then
|
|
DataRows = SRP_COM(objRecordSet, 'CALL', 'GetString', 2, -1, @FM, @RM)
|
|
If SQL_Services('HasConnectionObjectErrors', objConnection) then
|
|
Error = SQL_Services('GetConnectionObjectErrors', objConnection)
|
|
end
|
|
* If SRP_COM('', 'ERROR') then
|
|
* Error = SRP_COM('', 'ERROR')
|
|
* end
|
|
If DataRows[-1, 1] EQ @RM then DataRows[-1, 1] = ''
|
|
If DataRows EQ objRecordSet then
|
|
DataRows = ''
|
|
Error_Services('Add', 'Unknown ADO error in the ' : Service : ' service.')
|
|
end else
|
|
If SRP_COM('', 'ERROR') then
|
|
Error = SRP_COM('', 'ERROR')
|
|
If IndexC(Error, 'current record has been deleted', 1) then
|
|
DataRows = ''
|
|
end else
|
|
Error_Services('Add', 'ADO error in the ' : Service : ' service: ' : SRP_COM('', 'ERROR'))
|
|
end
|
|
end
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The objRecordSet argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = DataRows
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetServers
|
|
//
|
|
// Returns an @FM list of database servers.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetServers()
|
|
|
|
Servers = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If Servers EQ '' then
|
|
hSysEnv = Database_Services('GetTableHandle', 'SYSENV')
|
|
If Error_Services('NoError') then
|
|
Select hSysEnv
|
|
EOF = False$
|
|
Loop
|
|
Readnext SysEnvKeyID else EOF = True$
|
|
Until EOF
|
|
If SysEnvKeyID[1, 31] EQ 'SRP_DATA_EXPORT*CONNECTION_INFO' then Servers := SysEnvKeyID[-1, 'B*'] : @FM
|
|
Repeat
|
|
Servers[-1, 1] = ''
|
|
Servers = SRP_Array('SortRows', Servers, 'AL1', 'LIST', @FM, @VM)
|
|
Memory_Services('SetValue', ServiceKeyID, Servers)
|
|
end
|
|
end
|
|
|
|
Response = Servers
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetTableNames
|
|
//
|
|
// Server - Name of the server the connection object is bound to. This should be the same name that
|
|
// will be used in the Data Source connection string.
|
|
//
|
|
// Returns an @FM list of database table names available through the current Connection Object.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetTableNames(Server=Servers)
|
|
|
|
TableNames = ''
|
|
|
|
If Server NE '' then
|
|
objConnection = SQL_Services('GetConnectionObject', Server, 2)
|
|
If Error_Services('NoError') then
|
|
ErrorMessage = ''
|
|
QueryStatement = "SELECT table_name FROM information_schema.tables WHERE TABLE_TYPE='BASE TABLE' AND TABLE_SCHEMA = 'dbo'"
|
|
TableNames = SQL_Services('ExecuteQuery', objConnection, QueryStatement, True$)
|
|
If Error_Services('NoError') then
|
|
Convert @RM to @FM in TableNames
|
|
end else
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
end
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
If ErrorMessage NE '' then Error_Services('Add', ErrorMessage)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'Server argument was missing from the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = TableNames
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetTableColumns
|
|
//
|
|
// Server - Name of the server the connection object is bound to. This should be the same name that
|
|
// will be used in the Data Source connection string.
|
|
// TableName - Database Table whose column data is being requested.
|
|
//
|
|
// Returns an @FM/@VM array of database column information.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetTableColumns(Server=Servers, TableName, DoNotDestroy)
|
|
|
|
TableColumns = ''
|
|
If Unassigned(DoNotDestroy) Then DoNotDestroy = False$
|
|
If (Server NE '') AND (TableName NE '') then
|
|
objConnection = SQL_Services('GetConnectionObject', Server, 2)
|
|
If Error_Services('NoError') then
|
|
ErrorMessage = ''
|
|
* QueryStatement = 'SELECT column_name,data_type,character_maximum_length FROM information_schema.columns with (nolock) WHERE table_name = ' : "'" : TableName : "'"
|
|
QueryStatement = "SELECT '['+column_name+']' AS column_name,data_type,character_maximum_length FROM information_schema.columns with (nolock) WHERE table_name = " : "'" : TableName : "'"
|
|
TableColumns = SQL_Services('ExecuteQuery', objConnection, QueryStatement, True$)
|
|
If Error_Services('NoError') then
|
|
Convert @FM to @VM in TableColumns
|
|
Convert @RM to @FM in TableColumns
|
|
end else
|
|
ErrorMessage = Error_Services('GetMessage')
|
|
end
|
|
If DoNotDestroy = True$ Else
|
|
SQL_Services('DestroyConnectionObject', objConnection)
|
|
End
|
|
If ErrorMessage NE '' then Error_Services('Add', ErrorMessage)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The Server or TableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = TableColumns
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// SetOITableToSQLMap
|
|
//
|
|
// TableName - OpenInsight table being mapped. - [Required]
|
|
// SQLMap - JSON object containing the OI Table to SQL Map information. - [Required]
|
|
//
|
|
// Updates the stored JSON object that defines the mapping between the indicated OpenInsight table and the SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service SetOITableToSQLMap(TableName, SQLMap)
|
|
|
|
Convert @Lower_Case to @Upper_Case in TableName
|
|
ServiceKeyID = ServiceModule : '*' : 'GetOITableToSQLMap' : '*' : TableName
|
|
|
|
If (TableName NE '') AND (SQLMap NE '') then
|
|
Convert \0D0A\ to @FM in SQLMap ; // Makes it easier to inspect. The GetOITableToSQLMap service removes the @FMs.
|
|
Database_Services('WriteDataRow', 'DICT.' : TableName, '%SQLMap%', SQLMap, True$)
|
|
If Error_Services('NoError') then
|
|
Convert @FM to '' in SQLMap
|
|
Memory_Services('SetValue', ServiceKeyID, SQLMap)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The TableName or SQLMap argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetOITableToSQLMap
|
|
//
|
|
// TableName - OpenInsight table being mapped. - [Required]
|
|
//
|
|
// Returns JSON object that defines the mapping between the indicated OpenInsight table and the SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetOITableToSQLMap(TableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in TableName
|
|
|
|
ServiceKeyID := '*' : TableName
|
|
* OITableToSQLMap = Memory_Services('GetValue', ServiceKeyID)
|
|
OITableToSQLMap = ''
|
|
|
|
If OITableToSQLMap EQ '' then
|
|
If TableName NE '' then
|
|
OITableToSQLMap = Database_Services('ReadDataRow', 'DICT.' : TableName, '%SQLMap%')
|
|
Convert @FM to '' in OITableToSQLMap
|
|
If OITableToSQLMap NE '' then
|
|
Memory_Services('SetValue', ServiceKeyID, OITableToSQLMap)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The TableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = OITableToSQLMap
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// SetOIColumnToSQLMap
|
|
//
|
|
// TableName - OpenInsight table being mapped. - [Required]
|
|
// ColumnName - Database column from the OpenInsight table. - [Required]
|
|
// SQLMap - JSON object containing the OI Column to SQL Map information. - [Required]
|
|
//
|
|
// Updates the stored JSON object that defines the mapping between the indicated OpenInsight column and the SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service SetOIColumnToSQLMap(TableName, ColumnName, SQLMap)
|
|
|
|
Convert @Lower_Case to @Upper_Case in TableName
|
|
Convert @Lower_Case to @Upper_Case in ColumnName
|
|
ServiceKeyID = ServiceModule : '*' : 'GetOIColumnToSQLMap' : '*' : TableName : '*' : ColumnName
|
|
|
|
If (TableName NE '') AND (ColumnName NE '') AND (SQLMap NE '') then
|
|
Convert @FM to '' in SQLMap
|
|
Convert \0D0A\ to '' in SQLMap
|
|
ColumnData = Database_Services('ReadDataRow', 'DICT.' : TableName, ColumnName)
|
|
ColumnData<DICT_USER1$> = SQLMap
|
|
Database_Services('WriteDataRow', 'DICT.' : TableName, ColumnName, ColumnData, True$)
|
|
If Error_Services('NoError') then
|
|
Memory_Services('SetValue', ServiceKeyID, SQLMap)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The TableName, ColumnName, or SQLMap argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetAllOIColumnToSQLMaps
|
|
//
|
|
// TableName - OpenInsight table being mapped. - [Required]
|
|
//
|
|
// Returns an @FM/@VM delimited array of all JSON objects that define the mapping being the table columns and their
|
|
// respective SQL table columns. Columns with no maps will return an empty string for the JSON object.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetAllOIColumnToSQLMaps(TableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in TableName
|
|
ColumnSQLMaps = ''
|
|
|
|
If TableName NE '' then
|
|
FieldArray = Database_Services('ReadDataRow', 'DICT.' : TableName, '%FIELDS%')
|
|
ColumnNames = FieldArray<FIELDS_NAME$>
|
|
For Each ColumnName in ColumnNames using @VM
|
|
SQLMap = SQL_Services('GetOIColumnToSQLMap', TableName, ColumnName)
|
|
ColumnSQLMaps := ColumnName : @VM
|
|
If SQLMap NE '' then
|
|
ColumnSQLMaps := SQLMap
|
|
end
|
|
ColumnSQLMaps := @FM
|
|
Next ColumnName
|
|
ColumnSQLMaps[-1, 1] = ''
|
|
end else
|
|
Error_Services('Add', 'The TableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = ColumnSQLMaps
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetOIColumnToSQLMap
|
|
//
|
|
// TableName - OpenInsight table being mapped. - [Required]
|
|
// ColumnName - Database column from the OpenInsight table. - [Required]
|
|
//
|
|
// Returns JSON object that defines the mapping between the indicated OpenInsight table column and the SQL table column.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetOIColumnToSQLMap(TableName, ColumnName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in TableName
|
|
Convert @Lower_Case to @Upper_Case in ColumnName
|
|
ServiceKeyID := '*' : TableName : '*' : ColumnName
|
|
OIColumnToSQLMap = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If OIColumnToSQLMap EQ '' then
|
|
If (TableName NE '') AND (ColumnName NE '') then
|
|
ColumnData = Database_Services('ReadDataRow', 'DICT.' : TableName, ColumnName)
|
|
OIColumnToSQLMap = ColumnData<DICT_USER1$>
|
|
If OIColumnToSQLMap NE '' then
|
|
Memory_Services('SetValue', ServiceKeyID, OIColumnToSQLMap)
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The TableName or ColumnName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = OIColumnToSQLMap
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetSQLServer
|
|
//
|
|
// Returns the name of the SQL Server that the indicated OpenInsight table is mapped to.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetSQLServer(OITableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
ServiceKeyID := '*' : OITableName
|
|
SQLServer = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If SQLServer EQ '' then
|
|
If OITableName NE '' then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
SQLServer = SRP_JSON(MapObj, 'GETVALUE', 'SQLServer.Name')
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
If SQLServer NE '' then Memory_Services('SetValue', ServiceKeyID, SQLServer)
|
|
end else
|
|
Error_Services('Add', 'The OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = SQLServer
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetPrimarySQLTable
|
|
//
|
|
// Returns the name of the primary SQL table that the indicated OpenInsight table is mapped to.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetPrimarySQLTable(OITableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
ServiceKeyID := '*' : OITableName
|
|
PrimarySQLTable = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If PrimarySQLTable EQ '' then
|
|
If OITableName NE '' then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
PrimarySQLTable = SRP_JSON(MapObj, 'GETVALUE', 'PrimarySQLTable.Name')
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
If PrimarySQLTable NE '' then Memory_Services('SetValue', ServiceKeyID, PrimarySQLTable)
|
|
end else
|
|
Error_Services('Add', 'The OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = PrimarySQLTable
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetSecondarySQLTables
|
|
//
|
|
// Returns an @FM delimited list of the secondary SQL tables that the indicated OpenInsight table is mapped to.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetSecondarySQLTables(OITableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
ServiceKeyID := '*' : OITableName
|
|
SecondarySQLTables = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If SecondarySQLTables EQ '' then
|
|
If OITableName NE '' then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
TablesArray = SRP_JSON(MapObj, 'GET', 'SecondarySQLTables')
|
|
NumTables = SRP_JSON(TablesArray, 'GETCOUNT')
|
|
MatchFound = False$
|
|
For TableNum = 1 to NumTables
|
|
SecondarySQLTables := SRP_JSON(TablesArray, 'GETVALUE', '[' : TableNum : '].Name', '') : @FM
|
|
Until MatchFound
|
|
Next TableNum
|
|
SRP_JSON(TablesArray, 'RELEASE')
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
SecondarySQLTables[-1, 1] = ''
|
|
If SecondarySQLTables NE '' then Memory_Services('SetValue', ServiceKeyID, SecondarySQLTables)
|
|
end else
|
|
Error_Services('Add', 'The OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = SecondarySQLTables
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetStaticSQLColumnNames
|
|
//
|
|
// Returns an @FM delimited list of SQL column names that have a static value. These are usually used in a SQL insert
|
|
// statement along with the mapped columns.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetStaticSQLColumnNames(OITableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
ServiceKeyID := '*' : OITableName
|
|
* StaticSQLColumnNames = Memory_Services('GetValue', ServiceKeyID)
|
|
StaticSQLColumnNames = ''
|
|
|
|
If StaticSQLColumnNames EQ '' then
|
|
If (OITableName NE '') then
|
|
// Add all OpenInsight columns defined in the SQL Join Clause.
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
StaticColumnsArray = SRP_JSON(MapObj, 'GET', 'StaticColumns')
|
|
NumColumns = SRP_JSON(StaticColumnsArray, 'GETCOUNT')
|
|
For ColumnNum = 1 to NumColumns
|
|
objStaticColumn = SRP_JSON(StaticColumnsArray, 'GET', '[' : ColumnNum : ']')
|
|
StaticSQLColumnName = SRP_JSON(objStaticColumn, 'GETMEMBERS')
|
|
If StaticSQLColumnName[1, 1] EQ '(' then
|
|
Convert '(' to '[' in StaticSQLColumnName
|
|
Convert ')' to ']' in StaticSQLColumnName
|
|
end
|
|
StaticSQLColumnNames := StaticSQLColumnName : @FM
|
|
SRP_JSON(objStaticColumn, 'RELEASE')
|
|
Next NumColumns
|
|
StaticSQLColumnNames[-1, 1] = ''
|
|
SRP_JSON(StaticColumnsArray, 'RELEASE')
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
If StaticSQLColumnNames NE '' then Memory_Services('SetValue', ServiceKeyID, StaticSQLColumnNames)
|
|
end else
|
|
Error_Services('Add', 'The OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = StaticSQLColumnNames
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetStaticSQLColumnValues
|
|
//
|
|
// Returns an @FM delimited list of values for SQL column names that have a static value. These are usually used in a
|
|
// SQL insert statement along with the mapped columns.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetStaticSQLColumnValues(OITableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
ServiceKeyID := '*' : OITableName
|
|
StaticSQLColumnValues = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If StaticSQLColumnValues EQ '' then
|
|
If (OITableName NE '') then
|
|
// Add all OpenInsight columns defined in the SQL Join Clause.
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
StaticColumnsArray = SRP_JSON(MapObj, 'GET', 'StaticColumns')
|
|
NumColumns = SRP_JSON(StaticColumnsArray, 'GETCOUNT')
|
|
For ColumnNum = 1 to NumColumns
|
|
objStaticColumn = SRP_JSON(StaticColumnsArray, 'GET', '[' : ColumnNum : ']')
|
|
StaticSQLColumnName = SRP_JSON(objStaticColumn, 'GETMEMBERS')
|
|
StaticValue = SRP_JSON(objStaticColumn, 'GETVALUE', StaticSQLColumnName, '')
|
|
StaticValue = "'" : StaticValue : "'"
|
|
StaticSQLColumnValues := StaticValue : @FM
|
|
SRP_JSON(objStaticColumn, 'RELEASE')
|
|
Next NumColumns
|
|
StaticSQLColumnValues[-1, 1] = ''
|
|
SRP_JSON(StaticColumnsArray, 'RELEASE')
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
If StaticSQLColumnValues NE '' then Memory_Services('SetValue', ServiceKeyID, StaticSQLColumnValues)
|
|
end else
|
|
Error_Services('Add', 'The OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = StaticSQLColumnValues
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetAMVMaster
|
|
//
|
|
// Returns the name of the OpenInsight column used as the AMV (associated multivalue) master used to determine the
|
|
// number of values needed to write into the secondary SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetAMVMaster(OITableName, SQLTableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
ServiceKeyID := '*' : OITableName : '*' : SQLTableName
|
|
AMVMaster = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If AMVMaster EQ '' then
|
|
If (OITableName NE '') AND (SQLTableName NE '') then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
JoinArray = '' ; // Initialize the array.
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
PrimarySQLTableName = SRP_JSON(MapObj, 'GETVALUE', 'PrimarySQLTable.Name')
|
|
If SQLTableName _EQC PrimarySQLTableName then
|
|
// Primary SQL tables do not have a Seq Key. Just return the empty string.
|
|
end else
|
|
// Look for a matching secondary SQL table.
|
|
TablesArray = SRP_JSON(MapObj, 'GET', 'SecondarySQLTables')
|
|
NumTables = SRP_JSON(TablesArray, 'GETCOUNT')
|
|
MatchFound = False$
|
|
For TableNum = 1 to NumTables
|
|
SecondarySQLTableName = SRP_JSON(TablesArray, 'GETVALUE', '[' : TableNum : '].Name', '')
|
|
If SQLTableName _EQC SecondarySQLTableName then
|
|
AMVMaster = SRP_JSON(TablesArray, 'GETVALUE', '[' : TableNum : '].AMVMaster', '')
|
|
Swap '<none>' with '' in AMVMaster
|
|
MatchFound = True$
|
|
end
|
|
Until MatchFound
|
|
Next TableNum
|
|
SRP_JSON(TablesArray, 'RELEASE')
|
|
end
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
|
|
If AMVMaster NE '' then Memory_Services('SetValue', ServiceKeyID, AMVMaster)
|
|
end else
|
|
Error_Services('Add', 'The OITableName or SQLTableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = AMVMaster
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetJoinedOIColumns
|
|
//
|
|
// Returns an @FM list of column names from the indicated OpenInsight table that are used to join with the indicated
|
|
// SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetJoinedOIColumns(OITableName, SQLTableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
ServiceKeyID := '*' : OITableName : '*' : SQLTableName
|
|
JoinedOIColumns = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If JoinedOIColumns EQ '' then
|
|
If (OITableName NE '') AND (SQLTableName NE '') then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
JoinArray = '' ; // Initialize the array.
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
PrimarySQLTableName = SRP_JSON(MapObj, 'GETVALUE', 'PrimarySQLTable.Name')
|
|
If SQLTableName _EQC PrimarySQLTableName then
|
|
// Use the join array from the primary SQL Table.
|
|
JoinArray = SRP_JSON(MapObj, 'GET', 'PrimarySQLTable.JoinClause')
|
|
end else
|
|
// Look for a matching secondary SQL table.
|
|
TablesArray = SRP_JSON(MapObj, 'GET', 'SecondarySQLTables')
|
|
NumTables = SRP_JSON(TablesArray, 'GETCOUNT')
|
|
MatchFound = False$
|
|
For TableNum = 1 to NumTables
|
|
TableObj = SRP_JSON(TablesArray, 'GET', '[' : TableNum : ']')
|
|
SecondarySQLTableName = SRP_JSON(TableObj, 'GETVALUE', 'Name', '')
|
|
If SQLTableName _EQC SecondarySQLTableName then
|
|
JoinArray = SRP_JSON(TableObj, 'GET', 'JoinClause')
|
|
MatchFound = True$
|
|
end
|
|
SRP_JSON(TableObj, 'RELEASE')
|
|
Until MatchFound
|
|
Next TableNum
|
|
SRP_JSON(TablesArray, 'RELEASE')
|
|
end
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
|
|
If JoinArray GT 0 then
|
|
NumColumns = SRP_JSON(JoinArray, 'GETCOUNT')
|
|
For ColumnNo = 1 to NumColumns
|
|
OIColumnName = SRP_JSON(JoinArray, 'GETVALUE', '[' : ColumnNo : ']' : 'OIColumnName', '')
|
|
JoinedOIColumns := OIColumnName : @FM
|
|
Next ColumnNo
|
|
JoinedOIColumns[-1, 1] = ''
|
|
SRP_JSON(JoinArray, 'RELEASE')
|
|
end
|
|
|
|
If JoinedOIColumns NE '' then Memory_Services('SetValue', ServiceKeyID, JoinedOIColumns)
|
|
end else
|
|
Error_Services('Add', 'The OITableName or SQLTableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = JoinedOIColumns
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetJoinClause
|
|
//
|
|
// Returns a well formed join clause using the indicated OpenInsight Key ID and row for the indicated OpenInsight table
|
|
// and SQL table. Note: OIRow will likely be an empty string since most join clauses will be based on the OpenInsight
|
|
// Key ID.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetJoinClause(OITableName, SQLTableName, OIKeyID, OIRow)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
JoinClause = ''
|
|
|
|
If (OITableName NE '') AND (SQLTableName NE '') AND (OIKeyID NE '') then
|
|
OITableToSQLMap = SQL_Services('GetOITableToSQLMap', OITableName)
|
|
If Error_Services('NoError') then
|
|
FieldArray = Database_Services('ReadDataRow', 'DICT.' : OITablename, '%FIELDS%')
|
|
end
|
|
If Error_Services('NoError') then
|
|
JoinArray = '' ; // Initialize the array.
|
|
If SRP_JSON(MapObj, 'PARSE', OITableToSQLMap) EQ '' then
|
|
PrimarySQLTableName = SRP_JSON(MapObj, 'GETVALUE', 'PrimarySQLTable.Name')
|
|
If SQLTableName _EQC PrimarySQLTableName then
|
|
// Use the join array from the primary SQL Table.
|
|
JoinArray = SRP_JSON(MapObj, 'GET', 'PrimarySQLTable.JoinClause')
|
|
end else
|
|
// Look for a matching secondary SQL table.
|
|
TablesArray = SRP_JSON(MapObj, 'GET', 'SecondarySQLTables')
|
|
NumTables = SRP_JSON(TablesArray, 'GETCOUNT')
|
|
MatchFound = False$
|
|
For TableNum = 1 to NumTables
|
|
TableObj = SRP_JSON(TablesArray, 'GET', '[' : TableNum : ']')
|
|
SecondarySQLTableName = SRP_JSON(TableObj, 'GETVALUE', 'Name', '')
|
|
If SQLTableName _EQC SecondarySQLTableName then
|
|
JoinArray = SRP_JSON(TableObj, 'GET', 'JoinClause')
|
|
MatchFound = True$
|
|
end
|
|
SRP_JSON(TableObj, 'RELEASE')
|
|
Until MatchFound
|
|
Next TableNum
|
|
SRP_JSON(TablesArray, 'RELEASE')
|
|
end
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
|
|
If JoinArray GT 0 then
|
|
NumColumns = SRP_JSON(JoinArray, 'GETCOUNT')
|
|
For ColumnNo = 1 to NumColumns
|
|
JoinClause := SRP_JSON(JoinArray, 'GETVALUE', '[' : ColumnNo : ']' : 'SQLColumnName', '') : ' '
|
|
JoinClause := SRP_JSON(JoinArray, 'GETVALUE', '[' : ColumnNo : ']' : 'Operator', '') : ' '
|
|
OIColumnName = SRP_JSON(JoinArray, 'GETVALUE', '[' : ColumnNo : ']' : 'OIColumnName', '')
|
|
Locate OIColumnName in FieldArray<FIELDS_NAME$> using @VM setting vPos then
|
|
OIColumnType = FieldArray<FIELDS_TYPE$, vPos>
|
|
If OIColumnType EQ 'F' then
|
|
OIColumnPos = FieldArray<FIELDS_FIELD_NO$, vPos>
|
|
If OIColumnPos GT 0 then
|
|
OIColumnValue = OIRow<OIColumnPos>
|
|
end else
|
|
OIKeyPart = FieldArray<FIELDS_PART$, vPos>
|
|
OIColumnValue = Field(OIKeyID, '*', OIKeyPart, 1)
|
|
end
|
|
end else
|
|
* OIColumnValue = Calculate(OIColumnName) ; // Actual logic used in MFS
|
|
OIColumnValue = Xlate(OITableName, OIKeyID, OIColumnName, 'X')
|
|
end
|
|
end else
|
|
OIColumnValue = ''
|
|
end
|
|
JoinClause := "'" : OIColumnValue : "'"
|
|
JoinClause := @FM
|
|
Next ColumnNo
|
|
|
|
JoinClause[-1, 1] = ''
|
|
Swap @FM with ' AND ' in JoinClause
|
|
SRP_JSON(JoinArray, 'RELEASE')
|
|
end
|
|
end
|
|
end else
|
|
Error_Services('Add', 'The OITableName, SQLTableName, OIKeyID argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = JoinClause
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetMappedOIColumnNames
|
|
//
|
|
// Returns an @FM delimited list of OpenInsight column names from the indicated table that are mapped to the indicated
|
|
// SQL table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetMappedOIColumnNames(OITableName, SQLTableName)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
ServiceKeyID := '*' : OITableName : '*' : SQLTableName
|
|
MappedOIColumnNames = Memory_Services('GetValue', ServiceKeyID)
|
|
|
|
If MappedOIColumnNames EQ '' then
|
|
If (OITableName NE '') AND (SQLTableName NE '') then
|
|
// Add all OpenInsight columns defined in the SQL Join Clause.
|
|
JoinedOIColumns = SQL_Services('GetJoinedOIColumns', OITableName, SQLTableName)
|
|
If JoinedOIColumns NE '' then
|
|
Convert @VM to @FM in JoinedOIColumns
|
|
MappedOIColumnNames := JoinedOIColumns : @FM
|
|
end
|
|
|
|
// Go through all of the OpenInsight column SQL maps and add any column which is bound to the same SQL
|
|
// table. Note, one or more of these columns might already be in the list from the GetJoinedOIColumns service.
|
|
// These will be skipped.
|
|
AllOIColumnToSQLMaps = SQL_Services('GetAllOIColumnToSQLMaps', OITableName)
|
|
For Each OIColumnToSQLMap in AllOIColumnToSQLMaps using @FM setting fPos
|
|
If SRP_JSON(MapObj, 'PARSE', OIColumnToSQLMap<0, 2>) EQ '' then
|
|
MappedSQLTableName = SRP_JSON(MapObj, 'GETVALUE', 'SQLTableName')
|
|
If (MappedSQLTableName NE '') AND (SQLTableName EQ MappedSQLTableName) then
|
|
OIColumnName = OIColumnToSQLMap<0, 1>
|
|
Locate OIColumnName in MappedOIColumnNames using @FM setting fPos else
|
|
MappedOIColumnNames := OIColumnName : @FM
|
|
end
|
|
end
|
|
end
|
|
Next OIColumnToSQLMap
|
|
|
|
MappedOIColumnNames[-1, 1] = ''
|
|
If MappedOIColumnNames NE '' then Memory_Services('SetValue', ServiceKeyID, MappedOIColumnNames)
|
|
end else
|
|
Error_Services('Add', 'The OITableName or SQLTableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = MappedOIColumnNames
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetMappedSQLColumnNames
|
|
//
|
|
// Returns an @FM delimited list of SQL column names from the indicated table that are mapped from the indicated
|
|
// OpenInsight table and associated OpenInsight columns.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetMappedSQLColumnNames(OITableName, SQLTableName, OIColumns)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
ServiceKeyID := '*' : OITableName : '*' : SQLTableName
|
|
* MappedSQLColumnNames = Memory_Services('GetValue', ServiceKeyID)
|
|
MappedSQLColumnNames = ''
|
|
|
|
If MappedSQLColumnNames EQ '' then
|
|
If (OITableName NE '') AND (SQLTableName NE '') then
|
|
OIColumnNames = SQL_Services('GetMappedOIColumnNames', OITableName, SQLTableName)
|
|
If OIColumns NE '' then
|
|
OIColumnNames = SRP_Array('Join', OIColumnNames, OIColumns, 'AND', @FM)
|
|
end
|
|
For Each OIColumnName in OIColumnNames using @FM setting fPos
|
|
OIColumnToSQLMap = SQL_Services('GetOIColumnToSQLMap', OITableName, OIColumnName)
|
|
If Error_Services('NoError') then
|
|
If SRP_JSON(MapObj, 'PARSE', OIColumnToSQLMap) EQ '' then
|
|
MappedSQLColumnNames := SRP_JSON(MapObj, 'GETVALUE', 'SQLColumnName') : @FM
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
end
|
|
Next OIColumnName
|
|
|
|
MappedSQLColumnNames[-1, 1] = ''
|
|
If MappedSQLColumnNames NE '' then Memory_Services('SetValue', ServiceKeyID, MappedSQLColumnNames)
|
|
end else
|
|
Error_Services('Add', 'The OITableName or SQLTableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
end
|
|
|
|
Response = MappedSQLColumnNames
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetMappedSQLColumnValues
|
|
//
|
|
// Returns an @FM delimited list of SQL column values for the indicated table that are derived from the indicated
|
|
// OpenInsight table and associated OpenInsight columns. This service is normally called to create a fully formed Insert
|
|
// query statement.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetMappedSQLColumnValues(OITableName, SQLTableName, OIKeyID, OIRow, AMVPosition, OIColumns)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
If Num(AMVPosition) else AMVPosition = ''
|
|
|
|
MappedSQLColumnValues = ''
|
|
|
|
If (OITableName NE '') AND (SQLTableName NE '') AND (OIKeyID NE '') AND (OIRow NE '') then
|
|
FieldArray = Database_Services('ReadDataRow', 'DICT.' : OITablename, '%FIELDS%')
|
|
OIColumnNames = SQL_Services('GetMappedOIColumnNames', OITableName, SQLTableName)
|
|
If OIColumns NE '' then
|
|
OIColumnNames = SRP_Array('Join', OIColumnNames, OIColumns, 'AND', @FM)
|
|
end
|
|
If OIColumnNames NE '' then
|
|
For Each OIColumnName in OIColumnNames using @FM setting fPos
|
|
Locate OIColumnName in FieldArray<FIELDS_NAME$> using @VM setting vPos then
|
|
OIColumnToSQLMap = SQL_Services('GetOIColumnToSQLMap', OITableName, OIColumnName)
|
|
If Error_Services('NoError') then
|
|
If SRP_JSON(MapObj, 'PARSE', OIColumnToSQLMap) EQ '' then
|
|
SQLColumnType = SRP_JSON(MapObj, 'GETVALUE', 'SQLColumnType')
|
|
OIColumnType = FieldArray<FIELDS_TYPE$, vPos>
|
|
If OIColumnType EQ 'F' then
|
|
OIColumnPos = FieldArray<FIELDS_FIELD_NO$, vPos>
|
|
If OIColumnPos GT 0 then
|
|
OIColumnValue = OIRow<OIColumnPos>
|
|
end else
|
|
OIKeyPart = FieldArray<FIELDS_PART$, vPos>
|
|
OIColumnValue = Field(OIKeyID, '*', OIKeyPart, 1)
|
|
If OIColumnValue EQ '' then
|
|
Error_Services('Add', 'Key ID Column ' : OIColumnName : ' was assigned an empty string value in ' : Service : '.')
|
|
end
|
|
end
|
|
end else
|
|
// OIColumnValue = Calculate(OIColumnName) ; // Actual logic used in MFS
|
|
OIColumnValue = Xlate(OITablename, OIKeyID, OIColumnName, 'X')
|
|
end
|
|
If AMVPosition NE '' then
|
|
OIColumnValue = OIColumnValue<0, AMVPosition>
|
|
end
|
|
Begin Case
|
|
Case OIColumnValue EQ ''
|
|
// Empty strings are treated as NULL values.
|
|
OIColumnValue = 'NULL'
|
|
Case SQLColumnType[1, 7] _EQC 'VARCHAR' OR SQLColumnType _EQC 'CHAR'
|
|
// Single quote the value.
|
|
SQLColumnLength = SRP_JSON(MapObj, 'GETVALUE', 'SQLColumnLength')
|
|
If (SQLColumnLength EQ '') OR (SQLColumnLength EQ -1) then SQLColumnLength = Len(OIColumnValue)
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Fmt(OIColumnValue, OIColumnConv)
|
|
end
|
|
OIColumnValue = OIColumnValue[1, SQLColumnLength, 1]
|
|
Swap "'" with "''" in OIColumnValue
|
|
OIColumnValue = "'" : OIColumnValue : "'"
|
|
Case SQLColumnType _EQC 'INT'
|
|
// Oconv based on the OI column output conversion if it exists.
|
|
OIColumnConv = 'MD0'
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Fmt(OIColumnValue, OIColumnConv)
|
|
end
|
|
Case SQLColumnType _EQC 'NUMBER'
|
|
// Oconv based on the OI column output conversion if it exists.
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Fmt(OIColumnValue, OIColumnConv)
|
|
end
|
|
Case SQLColumnType _EQC 'DECIMAL'
|
|
// Oconv based on the OI column type.
|
|
// Oconv based on the OI column output conversion if it exists.
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Fmt(OIColumnValue, OIColumnConv)
|
|
end
|
|
Case SQLColumnType _EQC 'DATE'
|
|
OIColumnValue = "TO_DATE('" : Oconv(OIColumnValue, 'D4/J') : "', 'yyyy/mm/dd')"
|
|
Case Otherwise$
|
|
// Treat as a VARCHAR2 and single quote the value.
|
|
SQLColumnLength = SRP_JSON(MapObj, 'GETVALUE', 'SQLColumnLength')
|
|
If SQLColumnLength EQ '' then SQLColumnLength = Len(OIColumnValue)
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Fmt(OIColumnValue, OIColumnConv)
|
|
end
|
|
OIColumnValue = OIColumnValue[1, SQLColumnLength, 1]
|
|
Swap "'" with "''" in OIColumnValue
|
|
OIColumnValue = "'" : OIColumnValue : "'"
|
|
End Case
|
|
// Basic conversion rules.
|
|
Convert \09\ to ' ' in OIColumnValue
|
|
Swap \0D0A\ with ' ' in OIColumnValue
|
|
Convert @VM to '|' in OIColumnValue
|
|
Convert @SVM to ' ' in OIColumnValue
|
|
Convert @TM to ' ' in OIColumnValue
|
|
Convert @STM to ' ' in OIColumnValue
|
|
MappedSQLColumnValues := OIColumnValue : @FM
|
|
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
end
|
|
end
|
|
While Error_Services('NoError')
|
|
Next OIColumnName
|
|
end
|
|
MappedSQLColumnValues[-1, 1] = ''
|
|
end else
|
|
Error_Services('Add', 'The OITableName, SQLTableName, OIKeyID, or OIRow argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = MappedSQLColumnValues
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetSQLDeleteStatements
|
|
//
|
|
// Returns an @FM delimited list of SQL delete statements for the SQL table mapped to the indicated OpenInsight table.
|
|
// This will automatically create all SQL delete statements for secondary SQL tables as well. Note: OIRow will likely be
|
|
// an empty string since most join clauses will be based on the OpenInsight Key ID.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetSQLDeleteStatements(OITableName, OIKeyID, OIRow)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
SQLDeleteStatements = ''
|
|
|
|
If (OITableName NE '') AND (OIKeyID NE '') then
|
|
|
|
// Start with the primary SQL table that is mapped to this OpenInsight table.
|
|
PrimarySQLTableName = SQL_Services('GetPrimarySQLTable', OITableName)
|
|
JoinClause = SQL_Services('GetJoinClause', OITableName, PrimarySQLTableName, OIKeyID, OIRow)
|
|
SQLDeleteStatement = ''
|
|
SQLDeleteStatement := 'DELETE FROM ' : PrimarySQLTableName : ' '
|
|
SQLDeleteStatement := 'WHERE '
|
|
SQLDeleteStatement := JoinClause
|
|
SQLDeleteStatements := SQLDeleteStatement : @FM
|
|
|
|
// Add any secondary SQL table inserts that might be required.
|
|
SecondarySQLTableNames = SQL_Services('GetSecondarySQLTables', OITableName)
|
|
If SecondarySQLTableNames NE '' then
|
|
For Each SecondarySQLTableName in SecondarySQLTableNames using @FM
|
|
JoinClause = SQL_Services('GetJoinClause', OITableName, SecondarySQLTableName, OIKeyID, OIRow)
|
|
SQLDeleteStatement = ''
|
|
SQLDeleteStatement := 'DELETE FROM ' : SecondarySQLTableName : ' '
|
|
SQLDeleteStatement := 'WHERE '
|
|
SQLDeleteStatement := JoinClause
|
|
SQLDeleteStatements := SQLDeleteStatement : @FM
|
|
Next SecondarySQLTableName
|
|
end
|
|
|
|
SQLDeleteStatements[-1, 1] = ''
|
|
end else
|
|
Error_Services('Add', 'The OITableName or OIKeyID argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = SQLDeleteStatements
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetSQLInsertStatements
|
|
//
|
|
// Returns an @FM delimited list of SQL insert statements for the SQL table mapped to the indicated OpenInsight table.
|
|
// This will automatically create all SQL insert statements for secondary SQL tables as well.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetSQLInsertStatements(OITableName, OIKeyID, OIRow, OIColumns)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
SQLInsertStatements = ''
|
|
|
|
If (OITableName NE '') AND (OIKeyID NE '') AND (OIRow NE '') then
|
|
|
|
// Start with the primary SQL table that is mapped to this OpenInsight table.
|
|
PrimarySQLTableName = SQL_Services('GetPrimarySQLTable', OITableName)
|
|
MappedSQLColumnNames = SQL_Services('GetMappedSQLColumnNames', OITableName, PrimarySQLTableName, OIColumns)
|
|
MappedSQLColumnValues = SQL_Services('GetMappedSQLColumnValues', OITablename, PrimarySQLTableName, OIKeyID, OIRow, '', OIColumns)
|
|
StaticSQLColumnNames = SQL_Services('GetStaticSQLColumnNames', OITableName)
|
|
If StaticSQLColumnNames NE '' then
|
|
MappedSQLColumnNames := @FM : StaticSQLColumnNames
|
|
StaticSQLColumnValues = SQL_Services('GetStaticSQLColumnValues', OITableName)
|
|
MappedSQLColumnValues := @FM : StaticSQLColumnValues
|
|
end
|
|
Swap @FM with ', ' in MappedSQLColumnNames
|
|
Swap @FM with ", " in MappedSQLColumnValues
|
|
SQLInsertStatement = ''
|
|
SQLInsertStatement := 'INSERT INTO ' : PrimarySQLTableName : ' '
|
|
SQLInsertStatement := '('
|
|
SQLInsertStatement := MappedSQLColumnNames
|
|
SQLInsertStatement := ') VALUES ('
|
|
SQLInsertStatement := MappedSQLColumnValues
|
|
SQLInsertStatement := ')'
|
|
|
|
SQLInsertStatements := SQLInsertStatement : @FM
|
|
|
|
If Error_Services('NoError') then
|
|
// Add any secondary SQL table inserts that might be required.
|
|
SecondarySQLTableNames = SQL_Services('GetSecondarySQLTables', OITableName)
|
|
If SecondarySQLTableNames NE '' then
|
|
For Each SecondarySQLTableName in SecondarySQLTableNames using @FM
|
|
AMVMaster = SQL_Services('GetAMVMaster', OITableName, SecondarySQLTableName)
|
|
FieldArray = Database_Services('ReadDataRow', 'DICT.' : OITablename, '%FIELDS%')
|
|
If Error_Services('NoError') then
|
|
Locate AMVMaster in FieldArray<FIELDS_NAME$> using @VM setting vPos then
|
|
OIColumnType = FieldArray<FIELDS_TYPE$, vPos>
|
|
If OIColumnType EQ 'F' then
|
|
OIColumnPos = FieldArray<FIELDS_FIELD_NO$, vPos>
|
|
If OIColumnPos GT 0 then
|
|
OIColumnValue = OIRow<OIColumnPos>
|
|
end else
|
|
OIKeyPart = FieldArray<FIELDS_PART$, vPos>
|
|
OIColumnValue = Field(OIKeyID, '*', OIKeyPart, 1)
|
|
end
|
|
end else
|
|
// OIColumnValue = Calculate(OIColumnName) ; // Actual logic used in MFS
|
|
OIColumnValue = Xlate(OITablename, OIKeyID, OIColumnName, 'X')
|
|
end
|
|
NumPositions = DCount(OIColumnValue, @VM)
|
|
end else
|
|
NumPositions = 1
|
|
end
|
|
end else
|
|
NumPositions = 1
|
|
end
|
|
|
|
For AMVPosition = 1 to NumPositions
|
|
MappedSQLColumnNames = ''
|
|
MappedSQLColumnValues = ''
|
|
|
|
MappedSQLColumnNames := SQL_Services('GetMappedSQLColumnNames', OITableName, SecondarySQLTableName) : @FM
|
|
MappedSQLColumnValues := SQL_Services('GetMappedSQLColumnValues', OITablename, SecondarySQLTableName, OIKeyID, OIRow, AMVPosition) : @FM
|
|
|
|
MappedSQLColumnNames[-1, 1] = ''
|
|
MappedSQLColumnValues[-1, 1] = ''
|
|
|
|
Swap @FM with ', ' in MappedSQLColumnNames
|
|
Swap @FM with ", " in MappedSQLColumnValues
|
|
SQLInsertStatement = ''
|
|
SQLInsertStatement := 'INSERT INTO ' : SecondarySQLTableName : ' '
|
|
SQLInsertStatement := '('
|
|
SQLInsertStatement := MappedSQLColumnNames
|
|
SQLInsertStatement := ') VALUES ('
|
|
SQLInsertStatement := MappedSQLColumnValues
|
|
SQLInsertStatement := ')'
|
|
|
|
SQLInsertStatements := SQLInsertStatement : @FM
|
|
Next AMVPosition
|
|
Next SecondarySQLTableName
|
|
end
|
|
end
|
|
|
|
SQLInsertStatements[-1, 1] = ''
|
|
end else
|
|
Error_Services('Add', 'The OITableName, OIKeyID, or OIRow argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = SQLInsertStatements
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetSQLSelectStatement
|
|
//
|
|
// Returns the SQL select statement for the indicated SQL table based on its mapping to the indicated OpenInsight table.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetSQLSelectStatement(OITableName, SQLTableName, OIKeyID)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
SQLSelectStatement = ''
|
|
|
|
If (OITableName NE '') AND (SQLTableName NE '') AND (OIKeyID NE '') then
|
|
|
|
JoinClause = SQL_Services('GetJoinClause', OITableName, SQLTableName, OIKeyID)
|
|
MappedSQLColumnNames = SQL_Services('GetMappedSQLColumnNames', OITableName, SQLTableName)
|
|
Swap @FM with ', ' in MappedSQLColumnNames
|
|
SQLSelectStatement = ''
|
|
SQLSelectStatement := 'SELECT '
|
|
SQLSelectStatement := MappedSQLColumnNames : ' '
|
|
SQLSelectStatement := 'FROM ' : SQLTableName : ' '
|
|
SQLSelectStatement := 'WHERE '
|
|
SQLSelectStatement := JoinClause : ' '
|
|
|
|
end else
|
|
Error_Services('Add', 'The OITableName, SQLTableName, or OIKeyID argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = SQLSelectStatement
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// GetMappedOIColumnValues
|
|
//
|
|
// Returns an OpenInsight data row for the indicated table that are derived from the indicated SQL table and
|
|
// corresponding SQL data. Note, since data can come from multiple SQL tables, the OIRow arguments can already contain
|
|
// data from a previous call to this service. This allows primary and secondary SQL tables to be passed into this
|
|
// service so that all relevant SQL data can be denormalized into a single OpenInsight data row. This service is
|
|
// normally called to create a denormalized OpenInsight row.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service GetMappedOIColumnValues(OITableName, SQLTableName, SQLData, OIRow)
|
|
|
|
Convert @Lower_Case to @Upper_Case in OITableName
|
|
Convert @Lower_Case to @Upper_Case in SQLTableName
|
|
|
|
If (OITableName NE '') AND (SQLTableName NE '') AND (SQLData NE '') then
|
|
MappedOIColumnNames = SQL_Services('GetMappedOIColumnNames', OITableName, SQLTableName)
|
|
MappedSQLColumnNames = SQL_Services('GetMappedSQLColumnNames', OITableName, SQLTableName)
|
|
FieldArray = Database_Services('ReadDataRow', 'DICT.' : OITablename, '%FIELDS%')
|
|
If Error_Services('NoError') then
|
|
For Each SQLRow in SQLData using @RM setting ValuePos
|
|
For Each SQLColumnName in MappedSQLColumnNames using @FM setting fPos
|
|
OIColumnName = MappedOIColumnNames<fPos>
|
|
Locate OIColumnName in FieldArray<FIELDS_NAME$> using @VM setting vPos then
|
|
OIColumnType = FieldArray<FIELDS_TYPE$, vPos>
|
|
OIColumnPos = FieldArray<FIELDS_FIELD_NO$, vPos>
|
|
If OIColumnType EQ 'F' AND OIColumnPos NE 0 then
|
|
OIColumnToSQLMap = SQL_Services('GetOIColumnToSQLMap', OITableName, OIColumnName)
|
|
If Error_Services('NoError') then
|
|
If SRP_JSON(MapObj, 'PARSE', OIColumnToSQLMap) EQ '' then
|
|
SQLColumnType = SRP_JSON(MapObj, 'GETVALUE', 'SQLColumnType')
|
|
OIColumnValue = SQLRow<fPos>
|
|
Swap '<@VM>' with @VM in OIColumnValue
|
|
Swap @SVM with '<@SVM>' in OIColumnValue
|
|
Swap @TM with '<@TM>' in OIColumnValue
|
|
Swap @STM with '<@STM>' in OIColumnValue
|
|
Begin Case
|
|
Case OIColumnValue EQ '<NULL>'
|
|
// SQL <NULL> values are empty strings.
|
|
OIColumnValue = ''
|
|
Case SQLColumnType _EQC 'NUMBER'
|
|
// Oconv based on the OI column output conversion if it exists.
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Iconv(OIColumnValue, OIColumnConv)
|
|
end
|
|
Case SQLColumnType _EQC 'DECIMAL'
|
|
// Oconv based on the OI column type.
|
|
// Oconv based on the OI column output conversion if it exists.
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Iconv(OIColumnValue, OIColumnConv)
|
|
end
|
|
Case SQLColumnType _EQC 'DATE'
|
|
// Oconv based on the OI column output conversion if it exists, but only if
|
|
// the data is non-numeric.
|
|
If Alpha(OIColumnValue) then
|
|
OIColumnConv = FieldArray<FIELDS_CONV$, vPos>
|
|
If OIColumnConv NE '' then
|
|
OIColumnValue = Iconv(OIColumnValue, OIColumnConv)
|
|
end
|
|
end
|
|
End Case
|
|
OIRow<OIColumnPos, ValuePos> = OIColumnValue
|
|
end
|
|
SRP_JSON(MapObj, 'RELEASE')
|
|
end
|
|
end
|
|
end
|
|
Next SQLColumnName
|
|
Next SQLRow
|
|
end
|
|
|
|
end else
|
|
Error_Services('Add', 'The SQLTableName, SQLData, or OITableName argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
Response = OIRow
|
|
|
|
end service
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// LogConnectionActivity
|
|
//
|
|
// Appends the activity log for the Connection Object.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
Service LogConnectionActivity(Activity)
|
|
|
|
If Activity NE '' then
|
|
KeyID = '%SQL_CONNECTION_ACTIVITY_LOG%'
|
|
ActivityLog = Database_Services('ReadDataRow', 'CONTROL', KeyID)
|
|
If ActivityLog EQ '' then
|
|
Transfer Activity to ActivityLog
|
|
end else
|
|
ActivityLog := @FM :Activity
|
|
end
|
|
Database_Services('WriteDataRow', 'CONTROL', KeyID, ActivityLog, True$)
|
|
end else
|
|
Error_Services('Add', 'The Activity argument was missing in the ' : Service : ' service.')
|
|
end
|
|
|
|
end service
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Internal GoSubs
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|