Admin at 21:45, 19 December 2016

2016-12-19T21:45:26Z

← Older revision		Revision as of 21:45, 19 December 2016
Line 30:		Line 30:
	</pre>		</pre>

	In order to successfully initialize this new instance, point it toward its data files and supply a valid ~~license string~~.		In order to successfully initialize this new instance, point it toward its data files and supply a valid License Key.

	<pre>		<pre>

Admin: Created page with "{{MatchUpObjectIncrementalNav}} {{CustomTOC}} ==Basic Steps== These are the basic steps of a typical implementation of the Incremental interface. #Initialize the Incremental..."

2015-07-29T00:02:24Z

Created page with "{{MatchUpObjectIncrementalNav}} {{CustomTOC}} ==Basic Steps== These are the basic steps of a typical implementation of the Incremental interface. #Initialize the Incremental..."

New page

{{MatchUpObjectIncrementalNav}}

{{CustomTOC}}

==Basic Steps==
These are the basic steps of a typical implementation of the Incremental interface.
#Initialize the Incremental interface.
#:After creating an instance of the Incremental interface, point the object toward its supporting data file, select a matchcode and key file to use, and initialize these files.
#Create field mappings.
#:In order to build a key to compare to the key file, the Incremental interface needs to know which types of data the program will be passing to the interface and in what order.
#Read the record from the data source.
#:This can be a new address passed from a website, a single record from a newly acquired list or data source, to be compared against the master list.
#Build a match key for the incoming record.
#:This consists of passing the actual data to the interface in the same order used when creating a field mapping. After passing the necessary fields (usually a small subset of the fields from each record) via the [[MatchUp Object:Incremental:Match Key#AddField|AddField]] function, the Incremental interface uses this information to generate a match key.
#Compare the match key to the key file.
#:The [[MatchUp Object:Incremental:Comparison#MatchRecord|MatchRecord]] function searches the key file for any keys that match the new record. If it finds a match, it provides information on the duplicate records in the key file.
#Write new records to the key file.
#:The new key, whether or not it is unique, can then be written to the key file, so it can be used for future deduping operations. The program code must also write the new address record to the database separately.

==Pseudocode Implementation==
This is a common implementation of the Incremental interface using pseudocode for maximum clarity. Working sample programs in several programming languages can be found on the MatchUp Object install disc.

===Initialize the Incremental interface===
After creating an instance of the Incremental interface, point the object toward its supporting data file, select a matchcode and key file to use, and initialize these files.

First, create a new instance of the Incremental interface.

<pre>
SET mu = NEW mdMUIncremental
</pre>

In order to successfully initialize this new instance, point it toward its data files and supply a valid license string.

<pre>
CALL mu.SetLicenseString with LicenseString
CALL mu.SetPathToMatchUpFiles with PathToMatchUpFiles
</pre>

Before initialization, specify which matchcode and key file will be used for the current deduping operation.

<pre>
CALL mu.SetMatchcodeName with MatchCodeName
CALL mu.SetKeyFile with PathToKeyFile
</pre>

If all of the above have been set correctly, calling the [[MatchUp Object:Incremental:Mapping#InitializeDataFiles|InitializeDataFiles]] function should return a value of NoError. If it does not, call the [[MatchUp Object:Incremental:Mapping#GetInitializeErrorString|GetInitializeErrorString]] function to determine the reason for the failure to initialize.

<pre>
CALL mu.InitializeDataFiles RETURNING initResult
IF initResult is not NoError THEN
PRINT "Initialization Error: " + mu.GetInitializeErrorString
EXIT PROGRAM
END IF
</pre>

If the initialization was successful, call the following functions to display version and expiration information about the instance of MatchUp Object currently in use on the local computer.

<pre>
PRINT "Confirming Initialization: " + mu.GetInitializeErrorString
PRINT "Build Number: " + mu.GetBuildNumber
PRINT "Database Date: " + mu.GetDatabaseDate
PRINT "Database Expiration Date: " + mu.GetDatabaseExpirationDate
PRINT "License Expiration Date: " + mu.GetLicenseExpirationDate
</pre>

===Create field mappings===
Field mappings define a valid incoming type of data for each matchcode component. For example, a typical matchcode may include a five-digit ZIP Code, a last name, and a street address. But the data coming in, however, may contain the city, state, and ZIP as a single character field and the person’s full name as a single field as well.

Even if the fields in a database do not exactly match the components required by the matchcode, MatchUp Object is able to extract only the information it needs.

<pre>
CALL mu.ClearMappings
</pre>

After clearing any mappings from a previous use of the Incremental interface, call the [[MatchUp Object:Incremental:Mapping#AddMapping|AddMapping]] function once for each field being considered.

<pre>
CALL mu.AddMapping with mu.CityStZip RETURNING mapOK
CALL mu.AddMapping with mu.FullName RETURNING mapOK
CALL mu.AddMapping with mu.Address RETURNING mapOK
</pre>

===Get the record from the data source===
Regardless of the source, the object only needs to read the fields containing the data that the Incremental interface needs for comparison.

<pre>
READ Record FROM database RETURNING userInfo, CityStateZip, TheFullName, StreetAddress
</pre>

The userInfo field is any identifying character string that is unique to the current record.

Note that the Incremental interface does not handle database input and output. This must be done programmatically using whatever database interface is being used.

===Build the match key for the current record===
Now we use the data from the previous step to construct a match key to use in the next step.

<pre>
CALL mu.ClearFields
</pre>

After clearing any data from a previous use of the Incremental interface, call the [[MatchUp Object:Incremental:Match Key#AddField|AddField]] function once for each field being considered.

<pre>
CALL mu.AddField with CityStateZip
CALL mu.AddField with TheFullName
CALL mu.AddField with StreetAddress
</pre>

Pass the '''userInfo''' to the interface using the [[MatchUp Object:Incremental:Match Key#SetUserInfo|SetUserInfo]] function.

<pre>
CALL mu.SetUserInfo with userInfo
</pre>
The [[MatchUp Object:Incremental:Match Key#BuildKey|BuildKey]] function constructs the match key out of the information passed via the [[MatchUp Object:Incremental:Match Key#AddField|AddField]] function calls.

<pre>
CALL mu.BuildKey
</pre>

===Compare the match key to the key file===
The [[MatchUp Object:Incremental:Comparison#MatchRecord|MatchRecord]] function compares the match key to the key file and determines if the key already exists in the key file.

<pre>
CALL mu.MatchRecord
</pre>

Check the [[MatchUp Object:Incremental:Comparison#GetResults|GetResults]] function to determine if the [[MatchUp Object:Incremental:Comparison#MatchRecord|MatchRecord]] call produced a match, meaning that the current record is a duplicate to another one in the key file.

<pre>
CALL mu.GetResults RETURNING ResultsCodes
</pre>

If the record is a duplicate, this code retrieves information about the other duplicate records in the database.

<pre>
IF ResultsCodes contains “MS03” THEN // Record is a duplicate
PRINT "This record is in the database."
PRINT "There are " + mu.GetCount + " records in dupe group #" + mu.GetDupeGroup
PRINT "It matches these records:"
WHILE mu.NextMatchingRecord
PRINT "#" + mu.GetEntry + " is Record: " + mu.GetUserInfo
ENDWHILE

“Dupe Group” is a number that gets assigned to each unique record. Duplicate records are assigned the same number.

===Add the new key to the key file===
In this example, duplicate records are being rejected while unique records are being added to the database. Depending on the end user needs, the program may handle duplicate records differently.

<pre>
ELSE
CALL mu.AddRecord
Add New Record to master database
ENDIF
</pre>

The [[MatchUp Object:Incremental:Key File#AddRecord|AddRecord]] function only adds the new key to the key file. To add the data to the database, the developer would need to implement that in code, according to whatever database engine is in use.

==Using the Transaction Functions==
The [[MatchUp Object:Incremental:Transaction|transaction]] functions allow MatchUp Object to delay writing changes to the historical database until all records have been compared and all duplicates detected. After a call to the [[MatchUp Object:Incremental:Transaction#BeginTransaction|BeginTransaction]] function, the Incremental interface will cache all calls to the [[MatchUp Object:Incremental:Key File#AddRecord|AddRecord]] function until a call to the [[MatchUp Object:Incremental:Transaction#CommitTransaction|CommitTransaction]] function, which writes all changes to the keyfile in a single operation, significantly speeding up processing.

If any errors are detected, the [[MatchUp Object:Incremental:Transaction#RollbackTransaction|RollbackTransaction]] function flushes all [[MatchUp Object:Incremental:Key File#AddRecord|AddRecord]] function calls since the call to the [[MatchUp Object:Incremental:Transaction#BeginTransaction|BeginTransaction]] function and no changes will be written to the historical database.

Below is a simplified example of how transactions work with the Incremental interface.

<pre>
CALL BeginTransaction
FOR EACH Record in DatabaseTable
READ Record
Build Match Key
CALL MatchRecord
IF Record Is Unique THEN
CALL AddRecord
ENDIF
NEXT Record
IF ERROR
CALL RollbackTransaction
Return
ENDIF
CALL CommitTransaction
</pre>

[[Category:MatchUp Object]]

MatchUp Object:Incremental:Order of Operations - Revision history

Admin at 21:45, 19 December 2016

Admin: Created page with "{{MatchUpObjectIncrementalNav}} {{CustomTOC}} ==Basic Steps== These are the basic steps of a typical implementation of the Incremental interface. #Initialize the Incremental..."