Reference Guide#

Introduction #

Overview #

MatchUp Object Global is an extremely fast and powerful programmer’s tool that can be integrated into custom applications to eliminate duplicate records. Because merge/purge and data quality initiatives go hand in hand, the powerful features of this tool fulfill the needs of many companies. Reducing printing costs, increasing response rates, maintaining an efficient database, and achieving better quality data are just some of the many benefits of the merge/purge process.

MatchUp Object Global allows developers to customize exactly how to merge and purge data to suit their business needs. This gives people the flexibility to integrate MatchUp at different points of their processes, from point of entry to batch processing on the back end.

Component Matching

MatchUp Object Global can find matches in any combination of over 35 different components — from common ones like address, city, state, ZIP™, name, and

phone — to lesscommon elements, such as email address, company, gender, and social security number. Developers can even specify their own custom components. Each set of rules for matching is referred to as a matchcode, and a matchcode can apply up to 16 rules at a time. These rules are specified as combinations of components. A commonly used combination would be {Last Name + Street # + Street Name + ZIP Code™}, while another combination in the same matchcode would substitute PO Box™ for Street # and Street Name. With these options, the number of potential matching rules is limitless.

Matching Algorithms

MatchUp Object Global is a very sophisticated tool. If record 1 and 3 match with combination #1 in a matchcode, and record 2 and 3 match using combination #2-

MatchUp Object Global will use inferred matching and put records 1, 2, and 3 into the same group. It can split address, city/state/ZIP and name fields on the fly, as well as recognize phonemes like “ph” and “sh,” nicknames (Liz, Beth, Betty, Elizabeth), and alternate spellings of names (Gene, Jean, Jeanne).

MatchUp Object Global can also handle nearly-exact strings of characters, such as “Lewis” vs. “Ewis,” and “Palacino” vs. “Al Pacino” as well as initials such as “John Smith” to “J Smith.” These are just a few examples of the powerful matching algorithms at your disposal: Exact Match; Phonetic; Soundex; Containment; Frequency; Frequency Near; Fast Near; Accurate Near; Vowels Only; Consonants Only; Alphas Only; and Numerics Only.

Speed

Speed also is an important feature of MatchUp Object Global. It can process an average of 10 to 50 million records per hour. MatchUp Object Global includes a 64-bit

version to take advantage of newer processors and operating systems. The COM and .NET version of MatchUp Object Global eases integration with Microsoft languages.

Key Concepts #

The following concepts are essential to understanding the logic behind how MatchUp Object functions and successfully integrating the product into applications.

Match Keys #

Match Keys are string tokens that represent a database record. They contain only enough information necessary to determine a record’s unique or duplicate status.

Because they only contain a reduced portion of the data in the actual record, MatchUp Object is able to use these keys more efficiently than if it had to compare the complete record against every other record in the database.

Clustering #

Once a matchcode key is generated for a given record, it can be compared to the keys of other records. Ideally, every record’s key would be compared to every other record’s key. This, however, is not practical in all but very trivial applications because the number of comparisons grows geometrically with the number of records processed. For example, a record set of 100 records requires 4,950 comparisons (99 + 98 +…). A larger set of 10,000 records requires 49,995,000 comparisons (9,999 + 9,998 +…). Large record sets would take prohibitive amounts of time to process.

So we made the assumption that in order for two matchcode keys to be considered matching, there must be something in the keys that must match exactly. In many cases, this will be all or part of the ZIP/Postal Code. So what MatchUp Object does is only compare records that are (in this example) in the same ZIP or Postal Code. On the average (in the US using 5-digit ZIP codes), this will cut the average number of comparisons per record by a factor of thousands.

This concept is known as “break grouping,” “clustering,” “partitioning,” or “neighborhood sorting.” It is very likely that most, if not all other deduping programs have used some form of clustering method.

Here is an example set of matchcode keys using ZIP/Postal Code (5 characters), Last Name(4), First Name(2), Street Number(3), Street Name(5):

02346BERNMA49 GARD
02346BERNMA49 GARD
02357STARBR18 DAME
02357MILLLI123MAIN
03212STARMA18 DAME

MatchUp Object Global Features & Benefits #

Fast processing, about 10-50 million records per hour
Extremely flexible and customizable
22 powerful matching algorithms
Split name, address, and city/state/ZIP fields on the fly
Easy to learn and use
Sample Code provided in C#, VB.NET, C++, FoxPro, Java, SQL Server
Free tech support

Setup and List of Files #

To see how to set up the MatchUp Object Global, the list of files that will be downloaded and used, and the system requirements to run the Object, please visit the GitHub Sample Code.

Methods #

Initialization - Set #

The following functions prepare the Read/Write interface for use and link it to its supporting data files.

InitializeDataFiles #

Syntax:: InitializeDataFiles(String EncodingFormat);
Returns:: Initialize Status
Return Type:: ProgramStatus

This function opens the needed data files and prepares the MatchUp Object Global for use. Before calling this function, the application must have successfully called the SetLicenseString and SetPathToMatchUpFiles functions.

Check the return value of the GetInitializeErrorString function to retrieve the result of the initialization call. Any result other than “No Error” means the initialization failed for some reason.

This returns a value of the enumerated type ProgramStatus.

Value	Enumeration	Description
0	ErrorNone	No error - Initialization was successful.
1	ErrorConfigFile	Could not find mdMatchUp.dat.
2	ErrorLicenseExpired	The License Key has expired.
3	ErrorDatabaseExpired	The database has expired.
4	ErrorMatchcodeNotSpecified	No matchcode was specified.
5	ErrorMatchcodeNotFound	Specified Matchcode does not exist.
6	ErrorInvalidMatchcode	The specified matchcode is not valid.
7	ErrorKeyFile	The specified key file was not found.

If any other value other than “ErrorNone” is returned, check the GetInitializeErrorString function to see the reason for the error.

SetEncoding #

Syntax:: SetEncoding(String EncodingFormat);
Return Type:: Void

Optional. This function define encoded format of the input file and the resultant format of the build keys. Input data is converted into the UTF-8 format and processed as such. When GetKey is called, the data is converted back from UTF-8 to the specified input format.

The return value is 1 if the desired encoding can be set or 0 if the encoding is not recognized or can not be set.

It must be called before calling the InitializeDataFiles function.

The default encoding type is “ISO-8859-1”, if this function is not used.

SetGroupSorting #

Syntax:: SetGroupSorting();
Return Type:: Void

This function sets the Read-Write interface to return processed records in dupe group order. By default, the Read-Write interface returns records sorted by their match key. This should return records in the same dupe group together or close to each other.

Passing a boolean “True” value to this function will cause the Read-Write interface to return the processed records sorted into dupe groups.

The additional processing can increase the time needed to dedupe a large list and it is often possible to use the information returned by the Read-Write interface to sort records into this order programmatically.

SetKeyFile #

Syntax:: SetKeyFile(String KeyFile);
Return Type:: Void

This function selects the name and file path for the key file that will be used for the current Read-Write deduping operation.

Every instance of the Read-Write interface creates a new key file for each session. Any existing key file with the same name is overwritten. If more than one instance of the Read-Write interface is running on either the same computer or the same network, make certain that they do not point to the same key file. If one instance overwrites the key file being used by another instance, it can cause the second instance to fail.

SetLicenseString #

Syntax:: SetLicenseString(String License);
Returns:: Status
Return Type:: Integer

This function passes the License Key required for MatchUp Object Global to function. A value of “1” is returned if the License Key is valid, a value of “0” is returned for an invalid or empty string.

This function is only required if the environment variable method is not used.

Each customer is issued a License Key when purchasing MatchUp Object Global or renewing a subscription. This string must be passed to this function to unlock the functionality of MatchUp Object Global.

The License Key is normally set using an environment variable, either MD_LICENSE or MD_LICENSE_DEMO. Calling this function is an alternative method for setting the License Key, but applications developed for a production environment should only use the environment variable.

When using an environment variable, it is not necessary to call this function.

For more information on setting the environment variable, see Entering Your MatchUp Object Global License Key.

SetMatchcodeName #

Syntax:: SetLicenseString(String MatchcodeName);
Return Type:: Void

This function selects the matchcode to use for the current Read-Write deduping operation. The SetMatchcodeName function accepts a string value that must match the name of an existing matchcode in the current matchcode file.

SetMatchcodeObject #

Syntax:: SetMatchcodeObject(mdMUMatchcode);
Return Type:: Void

This functions selects the matchcode to use for the current Read-Write deduping operation. It largely duplicates the purpose of the SetMatchcodeName function, but instead of accepting a character value containing the name of a matchcode in the current matchcode file, this function accepts a Matchcode object created using the Matchcode Editing interface.

Because this function requires the use of a separate interface to create the Matchcode object variable, it is usually simpler to use the SetMatchcodeName function.

It is possible to use this function to build a new matchcode on the fly using the Matchcode Editing interface. Unless a specific application demands such flexibility, it is usually much simpler to add a new matchcode to the matchcode file and call it using the SetMatchcodeName function.

SetMaximumCharacterSize #

Syntax:: SetMaximumCharacterSize(Integer Size);
Return Type:: Void

Optional. This function will accommodate UTF-8 input data. Since a single UTF-8 character can be up to 4 bytes long, the storage of the matchcode keys may need to be altered to accommodate this maximum size. However, if you are working in a part of the world where you are sure that a byte sequence will always be shorter, you can use this function to override the storage overhead.

It must be called before calling the InitializeDataFiles function.

Valid input values are 1, 2, 3 or 4. Invalid values will be ignored and the default size (e.g. if this function is not called) is 1.

SetPathToMatchUpFiles #

Syntax:: SetPathToMatchUpFiles(String FilePath);
Return Type:: Void

String value. This function accepts a string value containing the path to the folder containing the MatchUp Read-Write data files. It must be called before calling the InitializeDataFiles function.

To provide maximum compatibility with Windows, three files are installed in your ‘Common App Data’ directory:

Windows Vista and newer: C:\ProgramData\MelissaDATA\MatchUp
Windows XP: C:\Documents and Settings\All Users\Application Data\Melissa DATA\MatchUp

The location of this directory can be changed by users so please note this, as it can often be the source of issues when running the samples/demos.

SetReserved #

Syntax:: SetReserved(String PropertyType, String PropertyValue);
Return Type:: Void

Optional. This function accepts two parameters: A string parameter containing the property to be set; and a string parameter representing the value for the property being set.

It must be called before calling the InitializeDataFiles function.

The unique identifier set by SetUserInfo and attached to built match keys is 1024 bytes by default. This lets you pass an advanced custom identifier or even source data to the key file. This can have data handling advantages but will slow down the process because the key file and temporary sort files will grow much larger than needed for most jobs. This function property has been added, allowing you to override the default UserInfo to a more efficient size.

Initialization - Get #

The following functions get values related to the initialization process.

GetBuildNumber #

Syntax:: GetBuildNumber();
Returns:: Build Number
Return Type:: String

This function returns the current development release build number of MatchUp Object Global.

GetDatabaseDate #

Syntax:: GetDatabaseDate();
Returns:: Database Date
Return Type:: String

This function returns a string value that represents the revision date of the MatchUp Object Global data files.

GetDatabaseExpirationDate #

Syntax:: GetDatabaseExpirationDate();
Returns:: Database Expiration Date
Return Type:: String

This function returns a string value containing the expiration date of the current database file (mdMatchUp.dat).

GetInitializeErrorString #

Syntax:: GetInitializeErrorString();
Returns:: Initialize Status
Return Type:: String

This function returns a string to describe the error caused when the InitializeDataFiles function cannot be successfully called.

The possible strings returned by this function are:

“No error”
“Could not find mdMatchUp.dat.”
“The License Key has expired.”
“The database has expired.”
“No matchcode was specified.”
“Specified Matchcode does not exist.”
“The specified matchcode is not valid.”
“The specified key file was not found.”

GetLicenseExpirationDate #

Syntax:: GetLicenseExpirationDate();
Returns:: License Expiration Date
Return Type:: String

This function returns a string value containing the expiration date of the current License Key. After this date, MatchUp Object will no longer function.

Mapping #

Before generating match keys for the database records, the application must supply the Read-Write interface with information about what sort of data it will be handling.

AddMapping #

Syntax:: AddMapping(mdMU.MatchcodeMapping);
Returns:: Mapping Allowed
Return Type:: Integer

This function selects the types of fields that will be used to build the match key and the order in which they will be added using the AddField function.

The function accepts an enumerated value of the type MatchcodeMapping. It tells the Read-Write interface which data types will be used for this deduping operation and in what order they will be passed to the deduper when passing data using the AddField function.

The data types used must contain the data expected by the matchcode being used, but it does not have to be an exact match. For example, if the matchcode requires a five-digit ZIP Code but the data in the list uses a single “City/State/ZIP” field, simply add the CityStZip mapping and pass the full string to the AddField function later. MatchUp Object Global is smart enough to use only the information it needs.

In another example, a matchcode calls for both last name and first name but database contains only full names. The application would simply apply the FullName mapping twice and pass the full name data twice to the AddField function.

To demonstrate the above:

mdMU->AddMapping(mdMU.CityStZip) // uses only ZIP Code
mdMU->AddMapping(mdMU.FullName) // uses last name only
mdMU->AddMapping(mdMU.FullName) // uses first name only
mdMU->AddMapping(mdMU.Address)

For a list of these enumerations, see Matchcode Mapping Enumerations.

The function returns a non-zero value if the mapping is allowed by the selected matchcode, false if the mapping caused an error.

ClearMappings #

Syntax:: ClearMappings();
Return Type:: Void

This function clears any existing field mappings.

It is a good idea to call this function before beginning to map fields, especially if the application may be required to perform multiple deduping operations in a single session.

Match Key #

These functions take the real data being compared and construct a match key according to the mappings defined with the Mapping functions and the matchcode defined when the Read/Write deduper was initialized.

AddField #

Syntax:: AddField(String Field);
Return Type:: Void

This function passes the contents of a field from a database to the deduper prior to calling the BuildKey function.

Fields must be passed to this function in the same order that the corresponding data types were mapped using the AddMapping function.

The following example expands on the previous AddMapping example. The matchcode uses five-digit ZIP codes, last and first names, in that order, and the street addresses. The list includes only a single “City/ST/ZIP” and a single full name field:

mdMU->AddField("Rancho Santa Margarita, CA 92688")
mdMU->AddField("Raymond F. Melissa")
mdMU->AddField("Raymond F. Melissa")
mdMU->AddField("22382 Avenida Empresa")

The deduper would use only the ZIP Code from the first field, the last name from the second AddField and first name from the third AddField.

BuildKey #

Syntax:: BuildKey();
Return Type:: Void

This function builds a match key using information passed via the AddField function.

The match key is built from:

Information passed via calls to the AddField function. Mapping defined by the AddMapping function. The pattern defined by the matchcode being used. A match key is a character string built according to a pattern defined by the current matchcode, consisting only of enough information to determine if the current record is unique or has a duplicate within the key file.

For example, let’s assume the matchcode called for a five-digit ZIP Code, first ten characters of a last name, first ten of a first name, a street number and the first ten characters of a street name. The current record is for Raymond F. Melissa at 22382 Avenida Empresa in the 92688 ZIP Code. The match key would be:

92688MELISSA   RAYMOND   22382EMPRESA

Because “Empresa” is only seven characters, the key would be padded with three spaces at the end.

ClearFields #

Syntax:: ClearFields();
Return Type:: Void

This function clears all values from previous calls to the AddField or ReadRecord function. The application should call this function after calling the WriteRecord function, before the first call to the AddField function, or before each call to the ReadRecord function.

SetKey #

Syntax:: SetKey(String MatchKey);
Return Type:: Void

This function accepts a match key before calling the ReadRecord function.

The BuildKey function creates a key from input data. If, however, the match keys are already stored in the source database, use this function to pass the keys to the deduper before calling MatchRecord.

SetUserInfo #

Syntax:: SetUserInfo(String UserInfo);
Return Type:: Void

This function accepts a character value that uniquely identifies each record in a set of data. The character value passed to this function must be unique for every record. This enables the application to associate the match key in the key file to the corresponding record in the list.

WriteRecord #

Syntax:: SetUserInfo(String UserInfo);
Return Type:: Void

This function creates a record of the current key and user info and writes it to the key file. This function requires that either the BuildKey or SetKey function, plus the SetUserInfo function, have previously been called. Then this function writes the information stored by the previously listed functions to a new record in the current key file.

The application cannot call this function after the Process function has been called.

Processing #

Process #

Syntax:: Process();
Return Type:: Void

This function switches the Read-Write interface from write mode to read mode. After calling this function, the application can no longer add more records to the key file with the WriteRecord function.

This function takes every record passed via the WriteRecord function and passes them through the Read-Write deduping logic to determine which are unique, which have duplicates, and which are duplicates.

Retrieval #

The functions in this section cycle through each record processed and return output unique/duplicate information.

ReadRecord #

Syntax:: ReadRecord();
Returns:: Was Record Found
Return Type:: Integer

This function reads the next record from the key file, if there is another record, and populates the fields used by the following functions:

GetResults
GetCount
GetDupeGroup
GetEntry
GetKey
GetUserInfo.

This function cannot be called until after the application has called the Process function.

If there are no more records, this returns an integer value of zero.

GetCount #

Syntax:: GetCount();
Returns:: Total Matching Records
Return Type:: Integer

If there were matches detected during processing, this function will return an integer value indicating the total number of matching records in this dupe group.

GetDupeGroup #

Syntax:: GetDupeGroup();
Returns:: Dupe Group Number
Return Type:: Long

Every unique record (one with no duplicates) will have a unique “Dupe Group” number. Any duplicate record will be assigned this same number. This function returns the Dupe Group number (a long integer value) of a matching record in the key file.

GetEntry #

Syntax:: GetEntry();
Returns:: Current Record Duplicate Entry
Return Type:: Integer

If the ReadRecord function detected at least one duplicate, this function will return an integer value that indicates where the current record falls within its dupe group.

For example, if this is the sixth matching record found, this function will return a 6.

GetKey #

Syntax:: GetKey();
Returns:: Match Key
Return Type:: String

This function returns the match key created by the last call to the BuildKey function and used by the last call to the ReadRecord function.

GetResults #

Syntax:: GetResults();
Returns:: Result Codes
Return Type:: String

This function returns a comma-delimited string of four-character codes that detail the output disposition of the last call to the ReadRecord function. It will also contain the result code of any matchcode combination which contributed to the present record matching other records in its dupe group.

This function is intended to replace the GetStatusCode (Deprecated) and GetCombinations (Deprecated) functions, providing a single source of information about the last Process function call and eliminating the need to perform bitwise operations on the GetCombinations (Deprecated) return value to determine which matchcode combinations contributed to the record matching other records in its Dupe Group.

The function returns one or more of the MatchUp Object Global Result Codes in a comma-delimited list.

GetUserInfo #

Syntax:: GetUserInfo();
Returns:: User Info
Return Type:: String

This function returns a character value containing the value passed to the SetUserInfo function. It returns the unique identifier associated with the record being checked by the Read-Write interface.

The application will need this information if the application has to match the current matchkey back to an original data source.

Deprecated Methods #

The following functions are recorded here for compatability and archiving purposes. Alternative functions should be used in practice.

GetStatusCode (Deprecated)#

This function is deprecated. You should use the GetResults function instead.

GetCombinations (Deprecated)#

Syntax:: GetCombinations();
Returns:: Matched Combination
Return Type:: Long

This function is deprecated. You should use the GetResults function instead.

Each matchcode may contain as many as 16 different combinations of data types that may be used to detect a match. A matching record may match more than one combination. This function returns a long integer value that can be used to determine which combination produced the match, if the ReadRecord function detected a matching key.

Enumerations #

MatchcodeCombination #

These Matchcode Combination enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetCombination function.

Name	Value
Combo1	0x0001
Combo2	0x0002
Combo3	0x0004
Combo4	0x0008
Combo5	0x0010
Combo6	0x0020
Combo7	0x0040
Combo8	0x0080
Combo9	0x0100
Combo10	0x0200
Combo11	0x0400
Combo12	0x0800
Combo13	0x1000
Combo14	0x2000
Combo15	0x4000
Combo16	0x8000

MatchcodeComponentType #

These Matchcode Component Type enumerations are used by the MatchUpObjectGlobal-ReferenceGuide-MGetComponentType, and MatchUpObjectGlobal-ReferenceGuide-MSetComponentType functions.

Name	Value
Prefix	1
First	2
Middle	3
Last	4
Suffix	5
Gender	6
FirstNickname	7
MiddleNickname	8
Title	9
Company	10
CompanyAcronym	11
StreetNumber	12
StreetPreDir	13
StreetName	14
StreetSuffix	15
StreetPostDir	16
POBox	17
Secondary	18
Address	19
City	20
State	21
Zip9	22
Zip5	23
Zip4	24
Country	28
CanadianPC	29
UKCity	30
UKCounty	31
UKPC	32
Phone	33
EMail	34
CreditCard	35
General	36
GeoDistance	38
Date	39
Numeric	40

MatchcodeFieldMatch #

These Matchcode Field Match enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetFieldMatch function.

Name	Value
NoFieldMatch	0x0000
BothBlankMatch	0x0100
OneBlankMatch	0x0200
InitialMatch	0x0400

MatchcodeFuzzy #

These Matchcode Fuzzy enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetFuzzy function.

Name	Value
NoFieldMatch	0x0000
BothBlankMatch	0x0100
OneBlankMatch	0x0200
InitialMatch	0x0400

MatchcodeMapping #

These Matchcode Mapping enumerations are used by the Read-Write AddMapping, Incremental interface MatchUpObjectGlobal-ReferenceGuide-IAddMapping, and Hybrid interface MatchUpObjectGlobal-ReferenceGuide-HAddMapping functions.

Name	Value
Prefix	1
Gender	2
First	3
MixedFirst	4
Middle	5
Last	6
MixedLast	7
Suffix	8
FullName	9
InverseName	10
GovernmentInverseName	11
Title	12
Company	13
Address	14
City	15
State	16
Zip9	17
Zip5	18
Zip4	19
CityStZip	20
Country	21
CanadianPostalCode	22
UKCity	23
UKCounty	24
UKPostcode	25
UKCityCountyPC	26
Phone	27
EMail	28
CreditCard	29
General	30
Latitude	40
Longitude	41
Date	42
Numeric	43
Address1	250
Address2	251
Address2	252

MatchcodeMappingTarget #

These Matchcode Mapping Target enumerations are used by the MatchUpObjectGlobal-ReferenceGuide-MGetMappingItemType function.

Name	Value
PrefixType	1
FirstType	2
MiddleType	3
LastType	4
SuffixType	5
GenderType	6
FirstNicknameType	7
MiddleNicknameType	8
TitleType	9
CompanyType	10
CompanyAcronymType	11
AddressType	12
CityType	13
StateType	14
Zip9Type	15
Zip5Type	16
Zip4Type	17
CountryType	18
CanadianPCType	19
UKCityType	20
UKCountyType	21
UKPCType	22
PhoneType	23
EMailType	24
CreditCardType	25
GeneralType	26
Address1Type	28
Address2Type	29
Address3Type	30
LatitudeType	34
LongitudeType	35
DateType	36
NumericType	37

MatchcodeStart #

These Matchcode enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetStart function.

Name	Value	Description
Left	0x08	The default. MatchUp Object Global starts counting from the beginning of the field.
Right	0x10	MatchUp Object Global starts counting backwards from the end of the field.
StartAtPos	0x20	MatchUp Object Global starts counting from the character position indicated by the SetStartPos function.
StartAtWord	0x40	MatchUp Object Global starts counting from the word indicated by the SetStartPos function.

MatchcodeStatus #

These Matchcode Status enumerations are used by the MatchUpObjectGlobal-ReferenceGuide-MAddMatchcodeItem, MatchUpObjectGlobal-ReferenceGuide-MInsertMatchcodeItem, MatchUpObjectGlobal-ReferenceGuide-MChangeMatchcodeItem, and MatchUpObjectGlobal-ReferenceGuide-MDeleteMatchcodeItem functions.

Name	Value
MCNoError	0
MCFirstComponentFuzzyOptions	1
MCFirstComponentNoSwapPair	2
MCDataTypeNoFuzzy	3
MCComponentFuzzyIncorrectSize	4
MCDataTypeNoMaximumNumberWords	5
MCDataTypeNoStartRightOrWordOrPos	6
MCIncorrectMaximumNumberWords	7
MCNearOutOfRange	8
MCFirstComponentNotUsedInEveryCondition	9
MCCannotChangeFirstComponent	10
MCInvalidSwapPair	11
MCInvalidMatchcodeComponentType	13

MatchcodeSwap #

These Matchcode Field Match enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetSwap function.

Name	Value
NoSwap	0x00
SwapA	0x01
SwapB	0x02
SwapC	0x04
SwapD	0x08
SwapE	0x10
SwapF	0x20
SwapG	0x40
SwapH	0x80
BothA	0x0100
BothB	0x0200
BothC	0x0400
BothD	0x0800
BothE	0x1000
BothF	0x2000
BothG	0x4000
BothH	0x8000

MatchcodeTrim #

These Matchcode Trim enumerations are used by the Matchcode MatchUpObjectGlobal-ReferenceGuide-MSetTrim function.

Name	Value
LeftTrim	0x02
RightTrim	0x04
AllTrim	0x06

Result Codes #

For details of all result codes please visit here

MS - Match Status #

Code	Short Description	Long Description
`MS01`	Unique Record	The record did not match any other records.
`MS02`	Has Duplicates	The record matched other records and was tagged as the output record.
`MS03`	Is Duplicate	The record matched other records and was tagged as a duplicate.
`MS04`	Record Suppressed	ETL Only. The source record was suppressed.
`MS05`	Record Not Intersected	ETL Only. The source record was not intersected.
`MS06`	Match: Rule 1	Records were matched by matchcode combination 1.
`MS07`	Match: Rule 2	Records were matched by matchcode combination 2.
`MS08`	Match: Rule 3	Records were matched by matchcode combination 3.
`MS09`	Match: Rule 4	Records were matched by matchcode combination 4.
`MS10`	Match: Rule 5	Records were matched by matchcode combination 5.
`MS11`	Match: Rule 6	Records were matched by matchcode combination 6.
`MS12`	Match: Rule 7	Records were matched by matchcode combination 7.
`MS13`	Match: Rule 8	Records were matched by matchcode combination 8.
`MS14`	Match: Rule 9	Records were matched by matchcode combination 9.
`MS15`	Match: Rule 10	Records were matched by matchcode combination 10.
`MS16`	Match: Rule 11	Records were matched by matchcode combination 11.
`MS17`	Match: Rule 12	Records were matched by matchcode combination 12.
`MS18`	Match: Rule 13	Records were matched by matchcode combination 13.
`MS19`	Match: Rule 14	Records were matched by matchcode combination 14.
`MS20`	Match: Rule 15	Records were matched by matchcode combination 15.
`MS21`	Match: Rule 16	Records were matched by matchcode combination 16.
`MS30`	Suppressor Record	ETL Only. The lookup record suppressed a source record.
`MS31`	Intersector Record	ETL Only. The lookup record intersected a source record.

Reference Guide

Contents

Reference Guide#