Class AddressFormatRow

Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com
Row Object for table 'AddressFormat'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Inheritance

object

SqlCommand

PrivateSave

TableRowBase

AddressFormatRow

Implements

INestedPersist

ISoDataLookup

ISentryIgnorable

Inherited Members

TableRowBase._saveOwner

TableRowBase._sentries

TableRowBase._relatedNestedPersistMembers

TableRowBase._isSaving

TableRowBase._sqlType

TableRowBase.InternalSetValue(int, object)

TableRowBase.InternalSetValue(SoField, object)

TableRowBase.GetFieldValue(FieldInfo)

TableRowBase.GetKnownFields()

TableRowBase.IsGhostField(FieldInfo)

TableRowBase.RowLoad()

TableRowBase.RowLoadAsync(ITableRowLoadHandler, CancellationToken)

TableRowBase.OnLoaded(IdxBase)

TableRowBase.Load(IdxBase, SoDataReader)

TableRowBase.Load(SoDataReader, TableInfo)

TableRowBase.SetDefaultsAsync(CancellationToken)

TableRowBase.SetDefaultsAsync(DashboardTileDefinitionRow, string, CancellationToken)

TableRowBase.SetSaveOwner(INestedPersist)

TableRowBase.GetForeignKeyHelperAsync(CancellationToken)

TableRowBase.SaveAsync()

TableRowBase.DeleteAsync()

TableRowBase.Validate()

TableRowBase.SetDirty(int, object, object)

TableRowBase.OnPreIdUpdateAsync()

TableRowBase.OnPrimaryKeyRequestAsync(PKContainer)

TableRowBase.OnPrimaryKeyUpdateAsync(PKContainer)

TableRowBase.OnIdUpdateAsync()

TableRowBase.BeginIgnoreSentryCheck()

TableRowBase.EndIgnoreSentryCheck()

TableRowBase.GetRelatedNestedPersist()

TableRowBase.RowLoad(ITableRowLoadHandler)

TableRowBase.this[int]

TableRowBase.this[SoField]

TableRowBase.Sentries

TableRowBase.IsDeleted

TableRowBase.IsSaving

TableRowBase.SqlType

TableRowBase.IsSentryIgnored

TableRowBase.IsMarkedForDelete

TableRowBase.OnElementSaved

TableRowBase.OnElementIdUpdate

PrivateSave.GetTableInfos()

PrivateSave.CloneToBasicUpdatingQuery()

PrivateSave.SetTicketLogAction(TicketLogAction, string)

PrivateSave.DoNotWriteTraveltransactionLog

PrivateSave.OnUpdateField

SqlCommand.Origin

SqlCommand.AdditionalInfo

SqlCommand.AddIgnoreAutoSentryTableInfo(TableInfo)

SqlCommand.AddIgnoreAutoSentryTableInfo(IEnumerable<TableInfo>)

SqlCommand.RemoveIgnoreAutoSentryTableInfo(TableInfo)

SqlCommand.ClearIgnoreAutoSentryTableInfos()

SqlCommand.IsAutoSentryIgnoredOnTableInfo(TableInfo)

SqlCommand.GetPrivateSaves()

SqlCommand.GetInserts()

SqlCommand.GetUpdates()

SqlCommand.GetDeletes()

SqlCommand.GetSelect()

SqlCommand.AutoSentryIgnoredTables

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

Namespace: SuperOffice.CRM.Rows

Assembly: SoDataBase.dll

Syntax

public class AddressFormatRow : TableRowBase, INestedPersist, ISoDataLookup, ISentryIgnorable

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Constructors

AddressFormatRow(AddressFormatRowIdxBase)

Constructor for the class taking an index as argument. Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com

Declaration

protected AddressFormatRow(AddressFormatRow.AddressFormatRowIdxBase idx)

Parameters

Type	Name	Description
AddressFormatRow.AddressFormatRowIdxBase	idx	The index representing a SELECT command to the database.

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Fields

_currentAddress1Flags

Current value, see property Address1Flags.

Declaration

protected short _currentAddress1Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Leadtext

Current value, see property Address1Leadtext.

Declaration

protected int _currentAddress1Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Length

Current value, see property Address1Length.

Declaration

protected short _currentAddress1Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Line

Current value, see property Address1Line.

Declaration

protected short _currentAddress1Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Mask

Current value, see property Address1Mask.

Declaration

protected string _currentAddress1Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Subpos

Current value, see property Address1Subpos.

Declaration

protected short _currentAddress1Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress1Zip

Current value, see property Address1Zip.

Declaration

protected short _currentAddress1Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Flags

Current value, see property Address2Flags.

Declaration

protected short _currentAddress2Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Leadtext

Current value, see property Address2Leadtext.

Declaration

protected int _currentAddress2Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Length

Current value, see property Address2Length.

Declaration

protected short _currentAddress2Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Line

Current value, see property Address2Line.

Declaration

protected short _currentAddress2Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Mask

Current value, see property Address2Mask.

Declaration

protected string _currentAddress2Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Subpos

Current value, see property Address2Subpos.

Declaration

protected short _currentAddress2Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress2Zip

Current value, see property Address2Zip.

Declaration

protected short _currentAddress2Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Flags

Current value, see property Address3Flags.

Declaration

protected short _currentAddress3Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Leadtext

Current value, see property Address3Leadtext.

Declaration

protected int _currentAddress3Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Length

Current value, see property Address3Length.

Declaration

protected short _currentAddress3Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Line

Current value, see property Address3Line.

Declaration

protected short _currentAddress3Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Mask

Current value, see property Address3Mask.

Declaration

protected string _currentAddress3Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Subpos

Current value, see property Address3Subpos.

Declaration

protected short _currentAddress3Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddress3Zip

Current value, see property Address3Zip.

Declaration

protected short _currentAddress3Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAddressformatId

Current value, see property AddressformatId.

Declaration

protected int _currentAddressformatId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentAtypeIdx

Current value, see property AtypeIdx.

Declaration

protected short _currentAtypeIdx

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityFlags

Current value, see property CityFlags.

Declaration

protected short _currentCityFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityLeadtext

Current value, see property CityLeadtext.

Declaration

protected int _currentCityLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityLength

Current value, see property CityLength.

Declaration

protected short _currentCityLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityLine

Current value, see property CityLine.

Declaration

protected short _currentCityLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityMask

Current value, see property CityMask.

Declaration

protected string _currentCityMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCitySubpos

Current value, see property CitySubpos.

Declaration

protected short _currentCitySubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCityZip

Current value, see property CityZip.

Declaration

protected short _currentCityZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyFlags

Current value, see property CountyFlags.

Declaration

protected short _currentCountyFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyLeadtext

Current value, see property CountyLeadtext.

Declaration

protected int _currentCountyLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyLength

Current value, see property CountyLength.

Declaration

protected short _currentCountyLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyLine

Current value, see property CountyLine.

Declaration

protected short _currentCountyLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyMask

Current value, see property CountyMask.

Declaration

protected string _currentCountyMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountySubpos

Current value, see property CountySubpos.

Declaration

protected short _currentCountySubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentCountyZip

Current value, see property CountyZip.

Declaration

protected short _currentCountyZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentExtraFlags

Current value, see property ExtraFlags.

Declaration

protected uint _currentExtraFlags

Field Value

Type	Description
uint

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentIsBuiltIn

Current value, see property IsBuiltIn.

Declaration

protected short _currentIsBuiltIn

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentLabelLayout

Current value, see property LabelLayout.

Declaration

protected string _currentLabelLayout

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentLabelLayout2

Current value, see property LabelLayout2.

Declaration

protected string _currentLabelLayout2

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentLayoutId

Current value, see property LayoutId.

Declaration

protected short _currentLayoutId

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentName

Current value, see property Name.

Declaration

protected string _currentName

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentRegistered

Current value, see property Registered.

Declaration

protected DateTime _currentRegistered

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentRegisteredAssociateId

Current value, see property RegisteredAssociateId.

Declaration

protected int _currentRegisteredAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateFlags

Current value, see property StateFlags.

Declaration

protected short _currentStateFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateLeadtext

Current value, see property StateLeadtext.

Declaration

protected int _currentStateLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateLength

Current value, see property StateLength.

Declaration

protected short _currentStateLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateLine

Current value, see property StateLine.

Declaration

protected short _currentStateLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateMask

Current value, see property StateMask.

Declaration

protected string _currentStateMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateSubpos

Current value, see property StateSubpos.

Declaration

protected short _currentStateSubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentStateZip

Current value, see property StateZip.

Declaration

protected short _currentStateZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentUpdated

Current value, see property Updated.

Declaration

protected DateTime _currentUpdated

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentUpdatedAssociateId

Current value, see property UpdatedAssociateId.

Declaration

protected int _currentUpdatedAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentUpdatedCount

Current value, see property UpdatedCount.

Declaration

protected short _currentUpdatedCount

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipFlags

Current value, see property ZipFlags.

Declaration

protected short _currentZipFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipLeadtext

Current value, see property ZipLeadtext.

Declaration

protected int _currentZipLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipLength

Current value, see property ZipLength.

Declaration

protected short _currentZipLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipLine

Current value, see property ZipLine.

Declaration

protected short _currentZipLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipMask

Current value, see property ZipMask.

Declaration

protected string _currentZipMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipSubpos

Current value, see property ZipSubpos.

Declaration

protected short _currentZipSubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_currentZipZip

Current value, see property ZipZip.

Declaration

protected short _currentZipZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Flags

Persisted value, see property Address1Flags.

Declaration

protected short _persistedAddress1Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Leadtext

Persisted value, see property Address1Leadtext.

Declaration

protected int _persistedAddress1Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Length

Persisted value, see property Address1Length.

Declaration

protected short _persistedAddress1Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Line

Persisted value, see property Address1Line.

Declaration

protected short _persistedAddress1Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Mask

Persisted value, see property Address1Mask.

Declaration

protected string _persistedAddress1Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Subpos

Persisted value, see property Address1Subpos.

Declaration

protected short _persistedAddress1Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress1Zip

Persisted value, see property Address1Zip.

Declaration

protected short _persistedAddress1Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Flags

Persisted value, see property Address2Flags.

Declaration

protected short _persistedAddress2Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Leadtext

Persisted value, see property Address2Leadtext.

Declaration

protected int _persistedAddress2Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Length

Persisted value, see property Address2Length.

Declaration

protected short _persistedAddress2Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Line

Persisted value, see property Address2Line.

Declaration

protected short _persistedAddress2Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Mask

Persisted value, see property Address2Mask.

Declaration

protected string _persistedAddress2Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Subpos

Persisted value, see property Address2Subpos.

Declaration

protected short _persistedAddress2Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress2Zip

Persisted value, see property Address2Zip.

Declaration

protected short _persistedAddress2Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Flags

Persisted value, see property Address3Flags.

Declaration

protected short _persistedAddress3Flags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Leadtext

Persisted value, see property Address3Leadtext.

Declaration

protected int _persistedAddress3Leadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Length

Persisted value, see property Address3Length.

Declaration

protected short _persistedAddress3Length

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Line

Persisted value, see property Address3Line.

Declaration

protected short _persistedAddress3Line

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Mask

Persisted value, see property Address3Mask.

Declaration

protected string _persistedAddress3Mask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Subpos

Persisted value, see property Address3Subpos.

Declaration

protected short _persistedAddress3Subpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddress3Zip

Persisted value, see property Address3Zip.

Declaration

protected short _persistedAddress3Zip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAddressformatId

Persisted value, see property AddressformatId.

Declaration

protected int _persistedAddressformatId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedAtypeIdx

Persisted value, see property AtypeIdx.

Declaration

protected short _persistedAtypeIdx

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityFlags

Persisted value, see property CityFlags.

Declaration

protected short _persistedCityFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityLeadtext

Persisted value, see property CityLeadtext.

Declaration

protected int _persistedCityLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityLength

Persisted value, see property CityLength.

Declaration

protected short _persistedCityLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityLine

Persisted value, see property CityLine.

Declaration

protected short _persistedCityLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityMask

Persisted value, see property CityMask.

Declaration

protected string _persistedCityMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCitySubpos

Persisted value, see property CitySubpos.

Declaration

protected short _persistedCitySubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCityZip

Persisted value, see property CityZip.

Declaration

protected short _persistedCityZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyFlags

Persisted value, see property CountyFlags.

Declaration

protected short _persistedCountyFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyLeadtext

Persisted value, see property CountyLeadtext.

Declaration

protected int _persistedCountyLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyLength

Persisted value, see property CountyLength.

Declaration

protected short _persistedCountyLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyLine

Persisted value, see property CountyLine.

Declaration

protected short _persistedCountyLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyMask

Persisted value, see property CountyMask.

Declaration

protected string _persistedCountyMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountySubpos

Persisted value, see property CountySubpos.

Declaration

protected short _persistedCountySubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedCountyZip

Persisted value, see property CountyZip.

Declaration

protected short _persistedCountyZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedExtraFlags

Persisted value, see property ExtraFlags.

Declaration

protected uint _persistedExtraFlags

Field Value

Type	Description
uint

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedIsBuiltIn

Persisted value, see property IsBuiltIn.

Declaration

protected short _persistedIsBuiltIn

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedLabelLayout

Persisted value, see property LabelLayout.

Declaration

protected string _persistedLabelLayout

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedLabelLayout2

Persisted value, see property LabelLayout2.

Declaration

protected string _persistedLabelLayout2

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedLayoutId

Persisted value, see property LayoutId.

Declaration

protected short _persistedLayoutId

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedName

Persisted value, see property Name.

Declaration

protected string _persistedName

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedRegistered

Persisted value, see property Registered.

Declaration

protected DateTime _persistedRegistered

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedRegisteredAssociateId

Persisted value, see property RegisteredAssociateId.

Declaration

protected int _persistedRegisteredAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateFlags

Persisted value, see property StateFlags.

Declaration

protected short _persistedStateFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateLeadtext

Persisted value, see property StateLeadtext.

Declaration

protected int _persistedStateLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateLength

Persisted value, see property StateLength.

Declaration

protected short _persistedStateLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateLine

Persisted value, see property StateLine.

Declaration

protected short _persistedStateLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateMask

Persisted value, see property StateMask.

Declaration

protected string _persistedStateMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateSubpos

Persisted value, see property StateSubpos.

Declaration

protected short _persistedStateSubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedStateZip

Persisted value, see property StateZip.

Declaration

protected short _persistedStateZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedUpdated

Persisted value, see property Updated.

Declaration

protected DateTime _persistedUpdated

Field Value

Type	Description
DateTime

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedUpdatedAssociateId

Persisted value, see property UpdatedAssociateId.

Declaration

protected int _persistedUpdatedAssociateId

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedUpdatedCount

Persisted value, see property UpdatedCount.

Declaration

protected short _persistedUpdatedCount

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipFlags

Persisted value, see property ZipFlags.

Declaration

protected short _persistedZipFlags

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipLeadtext

Persisted value, see property ZipLeadtext.

Declaration

protected int _persistedZipLeadtext

Field Value

Type	Description
int

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipLength

Persisted value, see property ZipLength.

Declaration

protected short _persistedZipLength

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipLine

Persisted value, see property ZipLine.

Declaration

protected short _persistedZipLine

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipMask

Persisted value, see property ZipMask.

Declaration

protected string _persistedZipMask

Field Value

Type	Description
string

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipSubpos

Persisted value, see property ZipSubpos.

Declaration

protected short _persistedZipSubpos

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

_persistedZipZip

Persisted value, see property ZipZip.

Declaration

protected short _persistedZipZip

Field Value

Type	Description
short

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Properties

Address1Flags

.NET type: short. Field flags for address1 field: See EAddrFormatFlags enum

Declaration

public virtual short Address1Flags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Leadtext

.NET type: int. Lead text resource ID for address1 field, 0 = no leadtext

Declaration

public virtual int Address1Leadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Length

.NET type: short. Field length in characters for address1 field

Declaration

public virtual short Address1Length { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Line

.NET type: short. Line no. for address1 field, 0 if not shown

Declaration

public virtual short Address1Line { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Mask

.NET type: string. Formatting mask for address1 field

Declaration

public virtual string Address1Mask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Subpos

.NET type: short. Position within line for address1 field

Declaration

public virtual short Address1Subpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address1Zip

.NET type: short. Zip lookup functionality for address1 field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short Address1Zip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Flags

.NET type: short. Field flags for address2 field: See EAddrFormatFlags enum

Declaration

public virtual short Address2Flags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Leadtext

.NET type: int. Lead text resource ID for address2 field, 0 = no leadtext

Declaration

public virtual int Address2Leadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Length

.NET type: short. Field length in characters for address2 field

Declaration

public virtual short Address2Length { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Line

.NET type: short. Line no. for address2 field, 0 if not shown

Declaration

public virtual short Address2Line { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Mask

.NET type: string. Formatting mask for address2 field

Declaration

public virtual string Address2Mask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Subpos

.NET type: short. Position within line for address2 field

Declaration

public virtual short Address2Subpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address2Zip

.NET type: short. Zip lookup functionality for address2 field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short Address2Zip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Flags

.NET type: short. Field flags for address3 field: See EAddrFormatFlags enum

Declaration

public virtual short Address3Flags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Leadtext

.NET type: int. Lead text resource ID for address3 field, 0 = no leadtext

Declaration

public virtual int Address3Leadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Length

.NET type: short. Field length in characters for address3 field

Declaration

public virtual short Address3Length { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Line

.NET type: short. Line no. for address3 field, 0 if not shown

Declaration

public virtual short Address3Line { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Mask

.NET type: string. Formatting mask for address3 field

Declaration

public virtual string Address3Mask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Subpos

.NET type: short. Position within line for address3 field

Declaration

public virtual short Address3Subpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Address3Zip

.NET type: short. Zip lookup functionality for address3 field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short Address3Zip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

AddressFormatTableInfo

Get the AddressFormatTableInfo object associated with the row.

Declaration

public AddressFormatTableInfo AddressFormatTableInfo { get; }

Property Value

Type	Description
AddressFormatTableInfo

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

AddressformatId

.NET type: int. Primary key

Declaration

public virtual int AddressformatId { get; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: PK.

This field is the primary key and can only be read, never written.

This field is not protected by the Sentry system, and can always be read

AtypeIdx

.NET type: short. Corresponds to Address.atype_idx

Declaration

public virtual short AtypeIdx { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityFlags

.NET type: short. Field flags for city field: See EAddrFormatFlags enum

Declaration

public virtual short CityFlags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityLeadtext

.NET type: int. Lead text resource ID for city field, 0 = no leadtext

Declaration

public virtual int CityLeadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityLength

.NET type: short. Field length in characters for city field

Declaration

public virtual short CityLength { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityLine

.NET type: short. Line no. for city field, 0 if not shown

Declaration

public virtual short CityLine { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityMask

.NET type: string. Formatting mask for city field

Declaration

public virtual string CityMask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CitySubpos

.NET type: short. Position within line for city field

Declaration

public virtual short CitySubpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CityZip

.NET type: short. Zip lookup functionality for city field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short CityZip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyFlags

.NET type: short. Field flags for county field: See EAddrFormatFlags enum

Declaration

public virtual short CountyFlags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyLeadtext

.NET type: int. Lead text resource ID for county field, 0 = no leadtext

Declaration

public virtual int CountyLeadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyLength

.NET type: short. Field length in characters for county field

Declaration

public virtual short CountyLength { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyLine

.NET type: short. Line no. for county field, 0 if not shown

Declaration

public virtual short CountyLine { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyMask

.NET type: string. Formatting mask for county field

Declaration

public virtual string CountyMask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountySubpos

.NET type: short. Position within line for county field

Declaration

public virtual short CountySubpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

CountyZip

.NET type: short. Zip lookup functionality for county field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short CountyZip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ExtraFlags

.NET type: uint. OBSOLETE: Extra flags for tag substitution mechanism, see idb.h. This function has been taken over by the tag-based formatting, controlled by the labelLayout and labelLayout2 fields

Declaration

public virtual uint ExtraFlags { get; set; }

Property Value

Type	Description
uint

Remarks

Original type in dictionary: UInt.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

InnerFieldValuePairs

The values of all the fields in the row.
The first field is the primary key.
The index of the value corresponds to the name of the field returned from the Fields property.

Declaration

protected override ArgumentParameterCollection InnerFieldValuePairs { get; }

Property Value

Type	Description
ArgumentParameterCollection

Overrides

PrivateSave.InnerFieldValuePairs

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

InnerPrimaryKey

The primary key needed to decide which specific row to alter with the current sql-command.

Declaration

protected override FieldInfo InnerPrimaryKey { get; }

Property Value

Type	Description
FieldInfo

Overrides

PrivateSave.InnerPrimaryKey

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

InnerPrimaryKeyValue

The actual value the primary key must have.

Declaration

protected override Parameter InnerPrimaryKeyValue { get; }

Property Value

Type	Description
Parameter

Overrides

PrivateSave.InnerPrimaryKeyValue

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

IsBuiltIn

.NET type: short. Is this row populated by SuperOffice?

Declaration

public virtual short IsBuiltIn { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: Bool.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

IsDirty

Is the row dirty, e.g. been modified since the last time it was saved to the database.

Declaration

public override bool IsDirty { get; }

Property Value

Type	Description
bool

Overrides

TableRowBase.IsDirty

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

IsNew

Is this object new, meaning that it does not exist in the database.

Declaration

public override bool IsNew { get; }

Property Value

Type	Description
bool

Overrides

TableRowBase.IsNew

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

this[string]

Get or set a value based on the name of the field.

Declaration

public override object this[string fieldName] { get; set; }

Parameters

Type	Name	Description
string	fieldName	Name of the field in the database

Property Value

Type	Description
object	Value of the field.

Overrides

TableRowBase.this[string]

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

LabelLayout

.NET type: string. Format specification for labels, uses standard tags

Declaration

public virtual string LabelLayout { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LabelLayout2

.NET type: string. Part two of format specification, concatenated with part one above

Declaration

public virtual string LabelLayout2 { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[255].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

LayoutId

.NET type: short. Corresponds to Country.layout_id

Declaration

public virtual short LayoutId { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: ShortId.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Name

.NET type: string. Name of address format (descriptive, multi-language)

Declaration

public virtual string Name { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[240].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Registered

.NET type: DateTime. Registered when in UTC

Declaration

public virtual DateTime Registered { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: UtcDateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

RegisteredAssociateId

.NET type: int. Registered by whom

Declaration

public virtual int RegisteredAssociateId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateFlags

.NET type: short. Field flags for state field: See EAddrFormatFlags enum

Declaration

public virtual short StateFlags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateLeadtext

.NET type: int. Lead text resource ID for state field, 0 = no leadtext

Declaration

public virtual int StateLeadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateLength

.NET type: short. Field length in characters for state field

Declaration

public virtual short StateLength { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateLine

.NET type: short. Line no. for state field, 0 if not shown

Declaration

public virtual short StateLine { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateMask

.NET type: string. Formatting mask for state field

Declaration

public virtual string StateMask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateSubpos

.NET type: short. Position within line for state field

Declaration

public virtual short StateSubpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

StateZip

.NET type: short. Zip lookup functionality for state field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short StateZip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

TableInfo

Get the TableInfo for the table.

Declaration

public override TableInfo TableInfo { get; }

Property Value

Type	Description
TableInfo	The TableInfo for the table.

Overrides

TableRowBase.TableInfo

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Updated

.NET type: DateTime. Last updated when in UTC

Declaration

public virtual DateTime Updated { get; set; }

Property Value

Type	Description
DateTime

Remarks

Original type in dictionary: UtcDateTime.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UpdatedAssociateId

.NET type: int. Last updated by whom

Declaration

public virtual int UpdatedAssociateId { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: FK.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

UpdatedCount

.NET type: short. Number of updates made to this record

Declaration

public virtual short UpdatedCount { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipFlags

.NET type: short. Field flags for zip field: See EAddrFormatFlags enum

Declaration

public virtual short ZipFlags { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipLeadtext

.NET type: int. Lead text resource ID for zip field, 0 = no leadtext

Declaration

public virtual int ZipLeadtext { get; set; }

Property Value

Type	Description
int

Remarks

Original type in dictionary: Id.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipLength

.NET type: short. Field length in characters for zip field

Declaration

public virtual short ZipLength { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipLine

.NET type: short. Line no. for zip field, 0 if not shown

Declaration

public virtual short ZipLine { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipMask

.NET type: string. Formatting mask for zip field

Declaration

public virtual string ZipMask { get; set; }

Property Value

Type	Description
string

Remarks

Original type in dictionary: String[10].

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipSubpos

.NET type: short. Position within line for zip field

Declaration

public virtual short ZipSubpos { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

ZipZip

.NET type: short. Zip lookup functionality for zip field: 0 = none, 1 = source, 2 = target

Declaration

public virtual short ZipZip { get; set; }

Property Value

Type	Description
short

Remarks

Original type in dictionary: UShort.

Setting this field to a new value will not affect the Sentry calculations and your rights

This field is not protected by the Sentry system, and can always be read

This field is not protected by the Sentry system, and can be written to unless other restrictions prevent it

Methods

CreateNew()

Create a new instance of the AddressFormatRow object. Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com

Declaration

public static AddressFormatRow CreateNew()

Returns

Type	Description
AddressFormatRow	A new instance of the AddressFormatRow object.

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

GetFromCustomSearch(CustomSearch)

Create a new instance of the AddressFormatRow object, and populate it with data from a custom search. If the search returns no results, an object with IsNew will be returned; if the result contains one row, an object representing that row will be returned. If the result contains more than one row, the first row will be used and the rest discarded (there is no way of detecting this situation).

Declaration

public static AddressFormatRow GetFromCustomSearch(AddressFormatRow.CustomSearch query)

Parameters

Type	Name	Description
AddressFormatRow.CustomSearch	query	The custom search to execute against the database

Returns

Type	Description
AddressFormatRow	A new instance of the AddressFormatRow object, reflecting the result of the query.

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

GetFromCustomSearchAsync(CustomSearch, CancellationToken)

Create a new instance of the AddressFormatRow object, and populate it with data from a custom search. If the search returns no results, an object with IsNew will be returned; if the result contains one row, an object representing that row will be returned. If the result contains more than one row, the first row will be used and the rest discarded (there is no way of detecting this situation).

Declaration

[CreateSyncVersion(OmitNullableDirective = true)]
public static Task<AddressFormatRow> GetFromCustomSearchAsync(AddressFormatRow.CustomSearch query, CancellationToken cancellationToken = default)

Parameters

Type	Name	Description
AddressFormatRow.CustomSearch	query	The custom search to execute against the database
CancellationToken	cancellationToken

Returns

Type	Description
Task<AddressFormatRow>	A new instance of the AddressFormatRow object, reflecting the result of the query.

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

GetFromIdxAddressformatIdAsync(int, CancellationToken)

Create a new instance of the AddressFormatRow object, by querying the database table via the index 'IDXAddressFormatId'. This method is intended to make it easy to use efficient queries that match a database index.

Declaration

public static Task<AddressFormatRow> GetFromIdxAddressformatIdAsync(int addressformatId, CancellationToken cancellationToken = default)

Parameters

Type	Name	Description
int	addressformatId
CancellationToken	cancellationToken

Returns

Type	Description
Task<AddressFormatRow>	Row object that represents the result of the search. IsNew will be true if the query did not match any row in the table

Remarks

This method represents one of the unique indexes on the AddressFormat table. Non-unique indexes have corresponding inner classes and methods in the AddressFormatRows collection, since they may return more than one row.

GetFromReader(SoDataReader, AddressFormatTableInfo)

Create a new instance of the AddressFormatRow object, and populate it with data from a reader/tableinfo. If the reader has DBNull as the current value of the primary key field, an unpopulated object with IsNew == true will be returned. If any fields are missing or one of the non-primary key fields is DBNull, an exception will be thrown. Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com

Declaration

public static AddressFormatRow GetFromReader(SoDataReader reader, AddressFormatTableInfo tableInfo)

Parameters

Type	Name	Description
SoDataReader	reader	SoDataReader positioned to a valid database row.
AddressFormatTableInfo	tableInfo	AddressFormatTableInfo instance used in the query that is the source of the reader. The fields used from the reader will be those owned by this tableinfo object.

Returns

Type	Description
AddressFormatRow	A new instance of the AddressFormatRow object.

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

GetPersistedFieldValue(FieldInfo)

Get the persisted value of a field.

Declaration

public override object GetPersistedFieldValue(FieldInfo field)

Parameters

Type	Name	Description
FieldInfo	field	Specification of a field

Returns

Type	Description
object	Field value, such as an int, DateTime, string ... Null can be returned if the value is not known.

Overrides

PrivateSave.GetPersistedFieldValue(FieldInfo)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

InternalSetValue(string, object)

Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com
Row Object for table 'AddressFormat'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration

protected override void InternalSetValue(string fieldName, object value)

Parameters

Type	Name	Description
string	fieldName
object	value

Overrides

TableRowBase.InternalSetValue(string, object)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

IsPersistedFieldValueKnown(FieldInfo)

Check if the persisted value for a field is known.

Declaration

public override bool IsPersistedFieldValueKnown(FieldInfo field)

Parameters

Type	Name	Description
FieldInfo	field	Specification of a field

Returns

Type	Description
bool	True if the value is known and sentry permits read.

Overrides

PrivateSave.IsPersistedFieldValueKnown(FieldInfo)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

OnLoad(SoDataReader, TableInfo)

Fill the object with data returned from the database.

Declaration

protected override void OnLoad(SoDataReader reader, TableInfo tableInfo)

Parameters

Type	Name	Description
SoDataReader	reader	Object holding the data returned from the database.
TableInfo	tableInfo	The TableInfo used for the SELECT statement.

Overrides

TableRowBase.OnLoad(SoDataReader, TableInfo)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

OnSaveAsync(BatchSave)

Add the object to the BatchSave list if it needs saving.

Declaration

protected override Task OnSaveAsync(BatchSave batchSave)

Parameters

Type	Name	Description
BatchSave	batchSave	Collection of objects to be saved within the transaction.

Returns

Type	Description
Task

Overrides

TableRowBase.OnSaveAsync(BatchSave)

Remarks

Classes overriding this method should call it.

OnSavedAsync(bool)

Method called after the save operation has been performed.

Declaration

protected override Task OnSavedAsync(bool bSucceeded)

Parameters

Type	Name	Description
bool	bSucceeded	True if the save operation succeeded (e.g. transaction committed), or false if the save operation failed (e.g. transaction rolled back)

Returns

Type	Description
Task

Overrides

TableRowBase.OnSavedAsync(bool)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Reset()

Reset the changes made on the object.

Declaration

protected override void Reset()

Overrides

TableRowBase.Reset()

Remarks

If the row is not persisted to the database (e.g. IsNew is true), all the values will be reset. If the row has been persisted to or loaded from the database, the properties will be set to those of the last persisted or loaded values.

SetDefaultsAsync(DefaulterStrategy, CancellationToken)

Set default values for the row.

Declaration

public override Task SetDefaultsAsync(DefaulterStrategy strategy, CancellationToken cancellationToken = default)

Parameters

Type	Name	Description
DefaulterStrategy	strategy	Strategy used when applying default values; values depend on where we are in the Create/Fetch/Populate/Save cycle
CancellationToken	cancellationToken

Returns

Type	Description
Task

Overrides

TableRowBase.SetDefaultsAsync(DefaulterStrategy, CancellationToken)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

SetPrimaryKey(int)

Set the primary key for the row.

Declaration

protected override void SetPrimaryKey(int primaryKey)

Parameters

Type	Name	Description
int	primaryKey	The new primary key for the row.

Overrides

TableRowBase.SetPrimaryKey(int)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

SetRowAsNew()

Address formats for GUI and labels. See more information: Addressformat on http://techdoc.superoffice.com
Row Object for table 'AddressFormat'. Row objects correspond directly to database tables, and one instance of a row object represents one row in the corresponding table in the database.

Declaration

public override void SetRowAsNew()

Overrides

TableRowBase.SetRowAsNew()

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

ToString()

ToString method intended for debugging, returns a string that displays the object type, new/dirty status, primary key and the string fields

Declaration

public override string ToString()

Returns

Type	Description
string

Overrides

object.ToString()

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Validate(RowValidator)

Validate this row.

Declaration

public override void Validate(RowValidator rowValidator)

Parameters

Type	Name	Description
RowValidator	rowValidator	RowValidator for inserting the result of the validation

Overrides

TableRowBase.Validate(RowValidator)

Remarks

Row objects can be created in several ways.

• Use the static CreateNew() method to create a new, empty object. After populating it with values, you call the SuperOffice.CRM.Data.TableRowBase.Save method and a corresponding row in the database is created, and the objects' primary key field updated. This is the preferred way to insert new rows into the database.
• You can create a (nested) AddressFormatRow AddressFormatRow.CustomSearch object to obtain a query pre-populated with the correct tableinfo and return fields. This query can be modified with restrictions, etc. Then, use the static GetFromCustomSearch(CustomSearch) method to apply the query to the database and obtain the result as a Row object. This is how you select existing rows from the database when you have a query that does not correspond to any of the existing database indexes.
• For each unique index defined for the table, there is a corresponding GetFromIdx method to make retrieving data via the indexes easy. Note that if you try to fetch a row that does not exist (for instance, by using the primary key index and specifying a primary key that does not exist in the database), you will get a Row object with the SuperOffice.CRM.Data.AddressFormatRow.IsNew and SuperOffice.CRM.Data.AddressFormatRow.IsDirty properties set to true. Such a Row object is called a 'ghost' and cannot be updated, saved or deleted. You can also get a ghost if the row does exist in the database, but the Sentry system denies Select rights to the row.
• Finally, if you have an SoDataReader that contains ALL the fields of the table, and you have the AddressFormatTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, AddressFormatTableInfo) method to create a new row object from the reader and the table info. This is useful when you have a larger, more complex query, for instance one that joins a number of tables, and you wish to use Row objects to process the result set. If your result set corresponds to an entity, consider using the corresponding Entity layer object instead, since entities automatically handle ID allocation and mapping, rights, and other higher-level aspects.

Non-unique indexes are handled through the AddressFormatRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a SuperOffice.CRM.Rows.AddressFormatRows.GetFromReader method to retrieve the results of queries that return more than one row.

Unique indexes on table AddressFormat are:

Index fields	Nested index class name

Implements

INestedPersist

ISoDataLookup

ISentryIgnorable

Extension Methods

EnumUtil.MapEnums<From, To>(From)

AddressFormatRecordDataExtensions.ToRecordData(AddressFormatRow)

Converters.MapEnums<From, To>(From)

QueryExectionExtensions.ExecuteNonQuery(SqlCommand)

QueryExectionExtensions.ExecuteNonQueryAsync(SqlCommand, CancellationToken)

QueryExectionExtensions.ExecuteReader(SqlCommand, bool)

QueryExectionExtensions.ExecuteReaderAsync(SqlCommand, bool, CancellationToken)

QueryExectionExtensions.ExecuteScalarAsync<T>(SqlCommand, bool, CancellationToken)

QueryExectionExtensions.ExecuteScalarAsync<T>(SqlCommand, CancellationToken)

QueryExectionExtensions.ExecuteScalar<T>(SqlCommand)