Class UDPersonSmallRow

User-defined fields
Row Object for table 'udpersonSmall'. 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

UDPersonSmallRow

Implements

INestedPersist

ISoDataLookup

ISentryIgnorable

ISoItem

Inherited Members

TableRowBase._saveOwner

TableRowBase._sentries

TableRowBase._relatedNestedPersistMembers

TableRowBase._isSaving

TableRowBase._sqlType

TableRowBase.InternalSetValue(Int32, Object)

TableRowBase.InternalSetValue(SoField, Object)

TableRowBase.GetFieldValue(FieldInfo)

TableRowBase.GetKnownFields()

TableRowBase.ISoDataLookup.GetPersistedFieldValue(FieldInfo)

TableRowBase.ISoDataLookup.IsPersistedFieldValueKnown(FieldInfo)

TableRowBase.IsGhostField(FieldInfo)

TableRowBase.RowLoad()

TableRowBase.RowLoad(ITableRowLoadHandler)

TableRowBase.OnLoaded(IdxBase)

TableRowBase.Load(IdxBase, SoDataReader)

TableRowBase.Load(SoDataReader, TableInfo)

TableRowBase.SetDefaults()

TableRowBase.SetDefaults(DashboardTileDefinitionRow, String)

TableRowBase.SetSaveOwner(INestedPersist)

TableRowBase.Save()

TableRowBase.Delete()

TableRowBase.add_OnElementSaved(OnSaved)

TableRowBase.remove_OnElementSaved(OnSaved)

TableRowBase.add_OnElementIdUpdate(OnIdUpdate)

TableRowBase.remove_OnElementIdUpdate(OnIdUpdate)

TableRowBase.Validate()

TableRowBase.SetDirty(Int32, Object, Object)

TableRowBase.INestedPersist.OnPreIdUpdate()

TableRowBase.INestedPersist.OnPrimaryKeyRequest(PKContainer)

TableRowBase.INestedPersist.OnPrimaryKeyUpdate(PKContainer)

TableRowBase.INestedPersist.OnIdUpdate()

TableRowBase.INestedPersist.OnSave(BatchSave)

TableRowBase.INestedPersist.OnSaved(Boolean)

TableRowBase.OnPreIdUpdate()

TableRowBase.OnPrimaryKeyRequest(PKContainer)

TableRowBase.OnPrimaryKeyUpdate(PKContainer)

TableRowBase.OnIdUpdate()

TableRowBase.BeginIgnoreSentryCheck()

TableRowBase.EndIgnoreSentryCheck()

TableRowBase.GetRelatedNestedPersist()

TableRowBase.Item[Int32]

TableRowBase.Item[SoField]

TableRowBase.Sentries

TableRowBase.ForeignKeyHelper

TableRowBase.IsDeleted

TableRowBase.IsSaving

TableRowBase.SqlType

TableRowBase.IsSentryIgnored

TableRowBase.IsMarkedForDelete

TableRowBase.OnElementSaved

TableRowBase.OnElementIdUpdate

PrivateSave.GetTableInfos()

PrivateSave.add_OnUpdateField(UpdateField)

PrivateSave.remove_OnUpdateField(UpdateField)

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

Namespace: SuperOffice.CRM.Rows

Assembly: SoDataBase.dll

Syntax

public class UDPersonSmallRow : TableRowBase, INestedPersist, ISoDataLookup, ISentryIgnorable, ISoItem

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Constructors

UDPersonSmallRow(UDPersonSmallRow.UDPersonSmallRowIdxBase)

Constructor for the class taking an index as argument. User-defined fields

Declaration

protected UDPersonSmallRow(UDPersonSmallRow.UDPersonSmallRowIdxBase idx)

Parameters

Type	Name	Description
UDPersonSmallRow.UDPersonSmallRowIdxBase	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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Fields

_currentDouble01

Current value, see property Double01.

Declaration

protected double _currentDouble01

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble02

Current value, see property Double02.

Declaration

protected double _currentDouble02

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble03

Current value, see property Double03.

Declaration

protected double _currentDouble03

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble04

Current value, see property Double04.

Declaration

protected double _currentDouble04

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble05

Current value, see property Double05.

Declaration

protected double _currentDouble05

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble06

Current value, see property Double06.

Declaration

protected double _currentDouble06

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble07

Current value, see property Double07.

Declaration

protected double _currentDouble07

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble08

Current value, see property Double08.

Declaration

protected double _currentDouble08

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble09

Current value, see property Double09.

Declaration

protected double _currentDouble09

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentDouble10

Current value, see property Double10.

Declaration

protected double _currentDouble10

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong01

Current value, see property Long01.

Declaration

protected int _currentLong01

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong02

Current value, see property Long02.

Declaration

protected int _currentLong02

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong03

Current value, see property Long03.

Declaration

protected int _currentLong03

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong04

Current value, see property Long04.

Declaration

protected int _currentLong04

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong05

Current value, see property Long05.

Declaration

protected int _currentLong05

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong06

Current value, see property Long06.

Declaration

protected int _currentLong06

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong07

Current value, see property Long07.

Declaration

protected int _currentLong07

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong08

Current value, see property Long08.

Declaration

protected int _currentLong08

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong09

Current value, see property Long09.

Declaration

protected int _currentLong09

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong10

Current value, see property Long10.

Declaration

protected int _currentLong10

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong11

Current value, see property Long11.

Declaration

protected int _currentLong11

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong12

Current value, see property Long12.

Declaration

protected int _currentLong12

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong13

Current value, see property Long13.

Declaration

protected int _currentLong13

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong14

Current value, see property Long14.

Declaration

protected int _currentLong14

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong15

Current value, see property Long15.

Declaration

protected int _currentLong15

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong16

Current value, see property Long16.

Declaration

protected int _currentLong16

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong17

Current value, see property Long17.

Declaration

protected int _currentLong17

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong18

Current value, see property Long18.

Declaration

protected int _currentLong18

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong19

Current value, see property Long19.

Declaration

protected int _currentLong19

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong20

Current value, see property Long20.

Declaration

protected int _currentLong20

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong21

Current value, see property Long21.

Declaration

protected int _currentLong21

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong22

Current value, see property Long22.

Declaration

protected int _currentLong22

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong23

Current value, see property Long23.

Declaration

protected int _currentLong23

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong24

Current value, see property Long24.

Declaration

protected int _currentLong24

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong25

Current value, see property Long25.

Declaration

protected int _currentLong25

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong26

Current value, see property Long26.

Declaration

protected int _currentLong26

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong27

Current value, see property Long27.

Declaration

protected int _currentLong27

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong28

Current value, see property Long28.

Declaration

protected int _currentLong28

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong29

Current value, see property Long29.

Declaration

protected int _currentLong29

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong30

Current value, see property Long30.

Declaration

protected int _currentLong30

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong31

Current value, see property Long31.

Declaration

protected int _currentLong31

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong32

Current value, see property Long32.

Declaration

protected int _currentLong32

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong33

Current value, see property Long33.

Declaration

protected int _currentLong33

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong34

Current value, see property Long34.

Declaration

protected int _currentLong34

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong35

Current value, see property Long35.

Declaration

protected int _currentLong35

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong36

Current value, see property Long36.

Declaration

protected int _currentLong36

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong37

Current value, see property Long37.

Declaration

protected int _currentLong37

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong38

Current value, see property Long38.

Declaration

protected int _currentLong38

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong39

Current value, see property Long39.

Declaration

protected int _currentLong39

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong40

Current value, see property Long40.

Declaration

protected int _currentLong40

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong41

Current value, see property Long41.

Declaration

protected int _currentLong41

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong42

Current value, see property Long42.

Declaration

protected int _currentLong42

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong43

Current value, see property Long43.

Declaration

protected int _currentLong43

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong44

Current value, see property Long44.

Declaration

protected int _currentLong44

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong45

Current value, see property Long45.

Declaration

protected int _currentLong45

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong46

Current value, see property Long46.

Declaration

protected int _currentLong46

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong47

Current value, see property Long47.

Declaration

protected int _currentLong47

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong48

Current value, see property Long48.

Declaration

protected int _currentLong48

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong49

Current value, see property Long49.

Declaration

protected int _currentLong49

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong50

Current value, see property Long50.

Declaration

protected int _currentLong50

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong51

Current value, see property Long51.

Declaration

protected int _currentLong51

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong52

Current value, see property Long52.

Declaration

protected int _currentLong52

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong53

Current value, see property Long53.

Declaration

protected int _currentLong53

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong54

Current value, see property Long54.

Declaration

protected int _currentLong54

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong55

Current value, see property Long55.

Declaration

protected int _currentLong55

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong56

Current value, see property Long56.

Declaration

protected int _currentLong56

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong57

Current value, see property Long57.

Declaration

protected int _currentLong57

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong58

Current value, see property Long58.

Declaration

protected int _currentLong58

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong59

Current value, see property Long59.

Declaration

protected int _currentLong59

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentLong60

Current value, see property Long60.

Declaration

protected int _currentLong60

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString01

Current value, see property String01.

Declaration

protected string _currentString01

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString02

Current value, see property String02.

Declaration

protected string _currentString02

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString03

Current value, see property String03.

Declaration

protected string _currentString03

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString04

Current value, see property String04.

Declaration

protected string _currentString04

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString05

Current value, see property String05.

Declaration

protected string _currentString05

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString06

Current value, see property String06.

Declaration

protected string _currentString06

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString07

Current value, see property String07.

Declaration

protected string _currentString07

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString08

Current value, see property String08.

Declaration

protected string _currentString08

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString09

Current value, see property String09.

Declaration

protected string _currentString09

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString10

Current value, see property String10.

Declaration

protected string _currentString10

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString11

Current value, see property String11.

Declaration

protected string _currentString11

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString12

Current value, see property String12.

Declaration

protected string _currentString12

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString13

Current value, see property String13.

Declaration

protected string _currentString13

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString14

Current value, see property String14.

Declaration

protected string _currentString14

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString15

Current value, see property String15.

Declaration

protected string _currentString15

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString16

Current value, see property String16.

Declaration

protected string _currentString16

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString17

Current value, see property String17.

Declaration

protected string _currentString17

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString18

Current value, see property String18.

Declaration

protected string _currentString18

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString19

Current value, see property String19.

Declaration

protected string _currentString19

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString20

Current value, see property String20.

Declaration

protected string _currentString20

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString21

Current value, see property String21.

Declaration

protected string _currentString21

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString22

Current value, see property String22.

Declaration

protected string _currentString22

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString23

Current value, see property String23.

Declaration

protected string _currentString23

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString24

Current value, see property String24.

Declaration

protected string _currentString24

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString25

Current value, see property String25.

Declaration

protected string _currentString25

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString26

Current value, see property String26.

Declaration

protected string _currentString26

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString27

Current value, see property String27.

Declaration

protected string _currentString27

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString28

Current value, see property String28.

Declaration

protected string _currentString28

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString29

Current value, see property String29.

Declaration

protected string _currentString29

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString30

Current value, see property String30.

Declaration

protected string _currentString30

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString31

Current value, see property String31.

Declaration

protected string _currentString31

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString32

Current value, see property String32.

Declaration

protected string _currentString32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString33

Current value, see property String33.

Declaration

protected string _currentString33

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString34

Current value, see property String34.

Declaration

protected string _currentString34

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString35

Current value, see property String35.

Declaration

protected string _currentString35

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString36

Current value, see property String36.

Declaration

protected string _currentString36

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString37

Current value, see property String37.

Declaration

protected string _currentString37

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString38

Current value, see property String38.

Declaration

protected string _currentString38

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString39

Current value, see property String39.

Declaration

protected string _currentString39

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentString40

Current value, see property String40.

Declaration

protected string _currentString40

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_currentUdpersonSmallId

Current value, see property UdpersonSmallId.

Declaration

protected int _currentUdpersonSmallId

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble01

Persisted value, see property Double01.

Declaration

protected double _persistedDouble01

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble02

Persisted value, see property Double02.

Declaration

protected double _persistedDouble02

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble03

Persisted value, see property Double03.

Declaration

protected double _persistedDouble03

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble04

Persisted value, see property Double04.

Declaration

protected double _persistedDouble04

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble05

Persisted value, see property Double05.

Declaration

protected double _persistedDouble05

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble06

Persisted value, see property Double06.

Declaration

protected double _persistedDouble06

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble07

Persisted value, see property Double07.

Declaration

protected double _persistedDouble07

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble08

Persisted value, see property Double08.

Declaration

protected double _persistedDouble08

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble09

Persisted value, see property Double09.

Declaration

protected double _persistedDouble09

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedDouble10

Persisted value, see property Double10.

Declaration

protected double _persistedDouble10

Field Value

Type	Description
Double

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong01

Persisted value, see property Long01.

Declaration

protected int _persistedLong01

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong02

Persisted value, see property Long02.

Declaration

protected int _persistedLong02

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong03

Persisted value, see property Long03.

Declaration

protected int _persistedLong03

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong04

Persisted value, see property Long04.

Declaration

protected int _persistedLong04

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong05

Persisted value, see property Long05.

Declaration

protected int _persistedLong05

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong06

Persisted value, see property Long06.

Declaration

protected int _persistedLong06

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong07

Persisted value, see property Long07.

Declaration

protected int _persistedLong07

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong08

Persisted value, see property Long08.

Declaration

protected int _persistedLong08

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong09

Persisted value, see property Long09.

Declaration

protected int _persistedLong09

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong10

Persisted value, see property Long10.

Declaration

protected int _persistedLong10

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong11

Persisted value, see property Long11.

Declaration

protected int _persistedLong11

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong12

Persisted value, see property Long12.

Declaration

protected int _persistedLong12

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong13

Persisted value, see property Long13.

Declaration

protected int _persistedLong13

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong14

Persisted value, see property Long14.

Declaration

protected int _persistedLong14

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong15

Persisted value, see property Long15.

Declaration

protected int _persistedLong15

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong16

Persisted value, see property Long16.

Declaration

protected int _persistedLong16

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong17

Persisted value, see property Long17.

Declaration

protected int _persistedLong17

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong18

Persisted value, see property Long18.

Declaration

protected int _persistedLong18

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong19

Persisted value, see property Long19.

Declaration

protected int _persistedLong19

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong20

Persisted value, see property Long20.

Declaration

protected int _persistedLong20

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong21

Persisted value, see property Long21.

Declaration

protected int _persistedLong21

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong22

Persisted value, see property Long22.

Declaration

protected int _persistedLong22

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong23

Persisted value, see property Long23.

Declaration

protected int _persistedLong23

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong24

Persisted value, see property Long24.

Declaration

protected int _persistedLong24

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong25

Persisted value, see property Long25.

Declaration

protected int _persistedLong25

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong26

Persisted value, see property Long26.

Declaration

protected int _persistedLong26

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong27

Persisted value, see property Long27.

Declaration

protected int _persistedLong27

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong28

Persisted value, see property Long28.

Declaration

protected int _persistedLong28

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong29

Persisted value, see property Long29.

Declaration

protected int _persistedLong29

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong30

Persisted value, see property Long30.

Declaration

protected int _persistedLong30

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong31

Persisted value, see property Long31.

Declaration

protected int _persistedLong31

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong32

Persisted value, see property Long32.

Declaration

protected int _persistedLong32

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong33

Persisted value, see property Long33.

Declaration

protected int _persistedLong33

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong34

Persisted value, see property Long34.

Declaration

protected int _persistedLong34

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong35

Persisted value, see property Long35.

Declaration

protected int _persistedLong35

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong36

Persisted value, see property Long36.

Declaration

protected int _persistedLong36

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong37

Persisted value, see property Long37.

Declaration

protected int _persistedLong37

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong38

Persisted value, see property Long38.

Declaration

protected int _persistedLong38

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong39

Persisted value, see property Long39.

Declaration

protected int _persistedLong39

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong40

Persisted value, see property Long40.

Declaration

protected int _persistedLong40

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong41

Persisted value, see property Long41.

Declaration

protected int _persistedLong41

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong42

Persisted value, see property Long42.

Declaration

protected int _persistedLong42

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong43

Persisted value, see property Long43.

Declaration

protected int _persistedLong43

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong44

Persisted value, see property Long44.

Declaration

protected int _persistedLong44

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong45

Persisted value, see property Long45.

Declaration

protected int _persistedLong45

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong46

Persisted value, see property Long46.

Declaration

protected int _persistedLong46

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong47

Persisted value, see property Long47.

Declaration

protected int _persistedLong47

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong48

Persisted value, see property Long48.

Declaration

protected int _persistedLong48

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong49

Persisted value, see property Long49.

Declaration

protected int _persistedLong49

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong50

Persisted value, see property Long50.

Declaration

protected int _persistedLong50

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong51

Persisted value, see property Long51.

Declaration

protected int _persistedLong51

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong52

Persisted value, see property Long52.

Declaration

protected int _persistedLong52

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong53

Persisted value, see property Long53.

Declaration

protected int _persistedLong53

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong54

Persisted value, see property Long54.

Declaration

protected int _persistedLong54

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong55

Persisted value, see property Long55.

Declaration

protected int _persistedLong55

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong56

Persisted value, see property Long56.

Declaration

protected int _persistedLong56

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong57

Persisted value, see property Long57.

Declaration

protected int _persistedLong57

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong58

Persisted value, see property Long58.

Declaration

protected int _persistedLong58

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong59

Persisted value, see property Long59.

Declaration

protected int _persistedLong59

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedLong60

Persisted value, see property Long60.

Declaration

protected int _persistedLong60

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString01

Persisted value, see property String01.

Declaration

protected string _persistedString01

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString02

Persisted value, see property String02.

Declaration

protected string _persistedString02

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString03

Persisted value, see property String03.

Declaration

protected string _persistedString03

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString04

Persisted value, see property String04.

Declaration

protected string _persistedString04

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString05

Persisted value, see property String05.

Declaration

protected string _persistedString05

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString06

Persisted value, see property String06.

Declaration

protected string _persistedString06

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString07

Persisted value, see property String07.

Declaration

protected string _persistedString07

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString08

Persisted value, see property String08.

Declaration

protected string _persistedString08

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString09

Persisted value, see property String09.

Declaration

protected string _persistedString09

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString10

Persisted value, see property String10.

Declaration

protected string _persistedString10

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString11

Persisted value, see property String11.

Declaration

protected string _persistedString11

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString12

Persisted value, see property String12.

Declaration

protected string _persistedString12

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString13

Persisted value, see property String13.

Declaration

protected string _persistedString13

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString14

Persisted value, see property String14.

Declaration

protected string _persistedString14

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString15

Persisted value, see property String15.

Declaration

protected string _persistedString15

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString16

Persisted value, see property String16.

Declaration

protected string _persistedString16

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString17

Persisted value, see property String17.

Declaration

protected string _persistedString17

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString18

Persisted value, see property String18.

Declaration

protected string _persistedString18

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString19

Persisted value, see property String19.

Declaration

protected string _persistedString19

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString20

Persisted value, see property String20.

Declaration

protected string _persistedString20

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString21

Persisted value, see property String21.

Declaration

protected string _persistedString21

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString22

Persisted value, see property String22.

Declaration

protected string _persistedString22

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString23

Persisted value, see property String23.

Declaration

protected string _persistedString23

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString24

Persisted value, see property String24.

Declaration

protected string _persistedString24

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString25

Persisted value, see property String25.

Declaration

protected string _persistedString25

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString26

Persisted value, see property String26.

Declaration

protected string _persistedString26

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString27

Persisted value, see property String27.

Declaration

protected string _persistedString27

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString28

Persisted value, see property String28.

Declaration

protected string _persistedString28

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString29

Persisted value, see property String29.

Declaration

protected string _persistedString29

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString30

Persisted value, see property String30.

Declaration

protected string _persistedString30

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString31

Persisted value, see property String31.

Declaration

protected string _persistedString31

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString32

Persisted value, see property String32.

Declaration

protected string _persistedString32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString33

Persisted value, see property String33.

Declaration

protected string _persistedString33

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString34

Persisted value, see property String34.

Declaration

protected string _persistedString34

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString35

Persisted value, see property String35.

Declaration

protected string _persistedString35

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString36

Persisted value, see property String36.

Declaration

protected string _persistedString36

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString37

Persisted value, see property String37.

Declaration

protected string _persistedString37

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString38

Persisted value, see property String38.

Declaration

protected string _persistedString38

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString39

Persisted value, see property String39.

Declaration

protected string _persistedString39

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedString40

Persisted value, see property String40.

Declaration

protected string _persistedString40

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

_persistedUdpersonSmallId

Persisted value, see property UdpersonSmallId.

Declaration

protected int _persistedUdpersonSmallId

Field Value

Type	Description
Int32

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Properties

Double01

.NET type: double. double value 1, indexed

Declaration

public virtual double Double01 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double02

.NET type: double. double value 2, indexed

Declaration

public virtual double Double02 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double03

.NET type: double. double value 3, indexed

Declaration

public virtual double Double03 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double04

.NET type: double. double value 4, indexed

Declaration

public virtual double Double04 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double05

.NET type: double. double value 5, not indexed

Declaration

public virtual double Double05 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double06

.NET type: double. double value 6, not indexed

Declaration

public virtual double Double06 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double07

.NET type: double. double value 7, not indexed

Declaration

public virtual double Double07 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double08

.NET type: double. double value 8, not indexed

Declaration

public virtual double Double08 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double09

.NET type: double. double value 9, not indexed

Declaration

public virtual double Double09 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Double10

.NET type: double. double value 10, not indexed

Declaration

public virtual double Double10 { get; set; }

Property Value

Type	Description
Double

Remarks

Original type in dictionary: Double.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0.0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

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
Boolean

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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
Boolean

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Item[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.Item[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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

Long01

.NET type: int. long value 1, indexed

Declaration

public virtual int Long01 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long02

.NET type: int. long value 2, indexed

Declaration

public virtual int Long02 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long03

.NET type: int. long value 3, indexed

Declaration

public virtual int Long03 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long04

.NET type: int. long value 4, indexed

Declaration

public virtual int Long04 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long05

.NET type: int. long value 5, not indexed

Declaration

public virtual int Long05 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long06

.NET type: int. long value 6, not indexed

Declaration

public virtual int Long06 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long07

.NET type: int. long value 7, not indexed

Declaration

public virtual int Long07 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long08

.NET type: int. long value 8, not indexed

Declaration

public virtual int Long08 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long09

.NET type: int. long value 9, not indexed

Declaration

public virtual int Long09 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long10

.NET type: int. long value 10, not indexed

Declaration

public virtual int Long10 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long11

.NET type: int. long value 11, not indexed

Declaration

public virtual int Long11 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long12

.NET type: int. long value 12, not indexed

Declaration

public virtual int Long12 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long13

.NET type: int. long value 13, not indexed

Declaration

public virtual int Long13 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long14

.NET type: int. long value 14, not indexed

Declaration

public virtual int Long14 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long15

.NET type: int. long value 15, not indexed

Declaration

public virtual int Long15 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long16

.NET type: int. long value 16, not indexed

Declaration

public virtual int Long16 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long17

.NET type: int. long value 17, not indexed

Declaration

public virtual int Long17 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long18

.NET type: int. long value 18, not indexed

Declaration

public virtual int Long18 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long19

.NET type: int. long value 19, not indexed

Declaration

public virtual int Long19 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long20

.NET type: int. long value 20, not indexed

Declaration

public virtual int Long20 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long21

.NET type: int. long value 21, not indexed

Declaration

public virtual int Long21 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long22

.NET type: int. long value 22, not indexed

Declaration

public virtual int Long22 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long23

.NET type: int. long value 23, not indexed

Declaration

public virtual int Long23 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long24

.NET type: int. long value 24, not indexed

Declaration

public virtual int Long24 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long25

.NET type: int. long value 25, not indexed

Declaration

public virtual int Long25 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long26

.NET type: int. long value 26, not indexed

Declaration

public virtual int Long26 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long27

.NET type: int. long value 27, not indexed

Declaration

public virtual int Long27 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long28

.NET type: int. long value 28, not indexed

Declaration

public virtual int Long28 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long29

.NET type: int. long value 29, not indexed

Declaration

public virtual int Long29 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long30

.NET type: int. long value 30, not indexed

Declaration

public virtual int Long30 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long31

.NET type: int. long value 31, not indexed

Declaration

public virtual int Long31 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long32

.NET type: int. long value 32, not indexed

Declaration

public virtual int Long32 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long33

.NET type: int. long value 33, not indexed

Declaration

public virtual int Long33 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long34

.NET type: int. long value 34, not indexed

Declaration

public virtual int Long34 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long35

.NET type: int. long value 35, not indexed

Declaration

public virtual int Long35 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long36

.NET type: int. long value 36, not indexed

Declaration

public virtual int Long36 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long37

.NET type: int. long value 37, not indexed

Declaration

public virtual int Long37 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long38

.NET type: int. long value 38, not indexed

Declaration

public virtual int Long38 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long39

.NET type: int. long value 39, not indexed

Declaration

public virtual int Long39 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long40

.NET type: int. long value 40, not indexed

Declaration

public virtual int Long40 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long41

.NET type: int. long value 41, not indexed

Declaration

public virtual int Long41 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long42

.NET type: int. long value 42, not indexed

Declaration

public virtual int Long42 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long43

.NET type: int. long value 43, not indexed

Declaration

public virtual int Long43 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long44

.NET type: int. long value 44, not indexed

Declaration

public virtual int Long44 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long45

.NET type: int. long value 45, not indexed

Declaration

public virtual int Long45 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long46

.NET type: int. long value 46, not indexed

Declaration

public virtual int Long46 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long47

.NET type: int. long value 47, not indexed

Declaration

public virtual int Long47 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long48

.NET type: int. long value 48, not indexed

Declaration

public virtual int Long48 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long49

.NET type: int. long value 49, not indexed

Declaration

public virtual int Long49 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long50

.NET type: int. long value 50, not indexed

Declaration

public virtual int Long50 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long51

.NET type: int. long value 51, not indexed

Declaration

public virtual int Long51 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long52

.NET type: int. long value 52, not indexed

Declaration

public virtual int Long52 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long53

.NET type: int. long value 53, not indexed

Declaration

public virtual int Long53 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long54

.NET type: int. long value 54, not indexed

Declaration

public virtual int Long54 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long55

.NET type: int. long value 55, not indexed

Declaration

public virtual int Long55 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long56

.NET type: int. long value 56, not indexed

Declaration

public virtual int Long56 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long57

.NET type: int. long value 57, not indexed

Declaration

public virtual int Long57 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long58

.NET type: int. long value 58, not indexed

Declaration

public virtual int Long58 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long59

.NET type: int. long value 59, not indexed

Declaration

public virtual int Long59 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

Long60

.NET type: int. long value 60, not indexed

Declaration

public virtual int Long60 { get; set; }

Property Value

Type	Description
Int32

Remarks

Original type in dictionary: Id.

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (0)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String01

.NET type: string. string value 1, indexed

Declaration

public virtual string String01 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String02

.NET type: string. string value 2, indexed

Declaration

public virtual string String02 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String03

.NET type: string. string value 3, indexed

Declaration

public virtual string String03 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String04

.NET type: string. string value 4, indexed

Declaration

public virtual string String04 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String05

.NET type: string. string value 5, not indexed

Declaration

public virtual string String05 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String06

.NET type: string. string value 6, not indexed

Declaration

public virtual string String06 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String07

.NET type: string. string value 7, not indexed

Declaration

public virtual string String07 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String08

.NET type: string. string value 8, not indexed

Declaration

public virtual string String08 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String09

.NET type: string. string value 9, not indexed

Declaration

public virtual string String09 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String10

.NET type: string. string value 10, not indexed

Declaration

public virtual string String10 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String11

.NET type: string. string value 11, not indexed

Declaration

public virtual string String11 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String12

.NET type: string. string value 12, not indexed

Declaration

public virtual string String12 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String13

.NET type: string. string value 13, not indexed

Declaration

public virtual string String13 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String14

.NET type: string. string value 14, not indexed

Declaration

public virtual string String14 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String15

.NET type: string. string value 15, not indexed

Declaration

public virtual string String15 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String16

.NET type: string. string value 16, not indexed

Declaration

public virtual string String16 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String17

.NET type: string. string value 17, not indexed

Declaration

public virtual string String17 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String18

.NET type: string. string value 18, not indexed

Declaration

public virtual string String18 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String19

.NET type: string. string value 19, not indexed

Declaration

public virtual string String19 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String20

.NET type: string. string value 20, not indexed

Declaration

public virtual string String20 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String21

.NET type: string. string value 21, not indexed

Declaration

public virtual string String21 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String22

.NET type: string. string value 22, not indexed

Declaration

public virtual string String22 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String23

.NET type: string. string value 23, not indexed

Declaration

public virtual string String23 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String24

.NET type: string. string value 24, not indexed

Declaration

public virtual string String24 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String25

.NET type: string. string value 25, not indexed

Declaration

public virtual string String25 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String26

.NET type: string. string value 26, not indexed

Declaration

public virtual string String26 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String27

.NET type: string. string value 27, not indexed

Declaration

public virtual string String27 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String28

.NET type: string. string value 28, not indexed

Declaration

public virtual string String28 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String29

.NET type: string. string value 29, not indexed

Declaration

public virtual string String29 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String30

.NET type: string. string value 30, not indexed

Declaration

public virtual string String30 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String31

.NET type: string. string value 31, not indexed

Declaration

public virtual string String31 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String32

.NET type: string. string value 32, not indexed

Declaration

public virtual string String32 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String33

.NET type: string. string value 33, not indexed

Declaration

public virtual string String33 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String34

.NET type: string. string value 34, not indexed

Declaration

public virtual string String34 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String35

.NET type: string. string value 35, not indexed

Declaration

public virtual string String35 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String36

.NET type: string. string value 36, not indexed

Declaration

public virtual string String36 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String37

.NET type: string. string value 37, not indexed

Declaration

public virtual string String37 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String38

.NET type: string. string value 38, not indexed

Declaration

public virtual string String38 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String39

.NET type: string. string value 39, not indexed

Declaration

public virtual string String39 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

String40

.NET type: string. string value 40, not indexed

Declaration

public virtual string String40 { get; set; }

Property Value

Type	Description
String

Remarks

Original type in dictionary: String[40].

You need to have Read access to get the value of this field. If you do not have access, you will get a blank value (string.Empty)

You need to have Write access to set this field to a new value (Sentry will throw exception otherwise)

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

Exceptions

Type	Condition
SoSentryException	Thrown if the set method is accessed without having the Write access right to the field

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

UdpersonSmallId

.NET type: int. Primary key

Declaration

public virtual int UdpersonSmallId { get; }

Property Value

Type	Description
Int32

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

UDPersonSmallTableInfo

Get the UDPersonSmallTableInfo object associated with the row.

Declaration

public UDPersonSmallTableInfo UDPersonSmallTableInfo { get; }

Property Value

Type	Description
UDPersonSmallTableInfo

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Methods

CreateNew()

Create a new instance of the UDPersonSmallRow object. User-defined fields

Declaration

public static UDPersonSmallRow CreateNew()

Returns

Type	Description
UDPersonSmallRow	A new instance of the UDPersonSmallRow 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

GetFromCustomSearch(UDPersonSmallRow.CustomSearch)

Create a new instance of the UDPersonSmallRow 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 UDPersonSmallRow GetFromCustomSearch(UDPersonSmallRow.CustomSearch query)

Parameters

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

Returns

Type	Description
UDPersonSmallRow	A new instance of the UDPersonSmallRow 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

GetFromIdxUdpersonSmallId(Int32)

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

Declaration

public static UDPersonSmallRow GetFromIdxUdpersonSmallId(int udpersonSmallId)

Parameters

Type	Name	Description
Int32	udpersonSmallId

Returns

Type	Description
UDPersonSmallRow	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 UDPersonSmall table. Non-unique indexes have corresponding inner classes and methods in the UDPersonSmallRows collection, since they may return more than one row.

GetFromReader(SoDataReader, UDPersonSmallTableInfo)

Create a new instance of the UDPersonSmallRow 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. User-defined fields

Declaration

public static UDPersonSmallRow GetFromReader(SoDataReader reader, UDPersonSmallTableInfo tableInfo)

Parameters

Type	Name	Description
SoDataReader	reader	SoDataReader positioned to a valid database row.
UDPersonSmallTableInfo	tableInfo	UDPersonSmallTableInfo 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
UDPersonSmallRow	A new instance of the UDPersonSmallRow 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Exceptions

Type	Condition
ArgumentException	Thrown if the field is not known.

InternalSetValue(String, Object)

User-defined fields
Row Object for table 'udpersonSmall'. 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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
Boolean	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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

OnSave(BatchSave)

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

Declaration

protected override void OnSave(BatchSave batchSave)

Parameters

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

Overrides

TableRowBase.OnSave(BatchSave)

Remarks

Classes overriding this method should call it.

OnSaved(Boolean)

Method called after the save operation has been performed.

Declaration

protected override void OnSaved(bool bSucceeded)

Parameters

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

Overrides

TableRowBase.OnSaved(Boolean)

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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.

SetDefaults(DefaulterStrategy)

Set default values for the row.

Declaration

public override void SetDefaults(DefaulterStrategy strategy)

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

Overrides

TableRowBase.SetDefaults(DefaulterStrategy)

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

SetPrimaryKey(Int32)

Set the primary key for the row.

Declaration

protected override void SetPrimaryKey(int primaryKey)

Parameters

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

Overrides

TableRowBase.SetPrimaryKey(Int32)

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

SetRowAsNew()

User-defined fields
Row Object for table 'udpersonSmall'. 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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

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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall 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 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) UDPersonSmallRow UDPersonSmallRow.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(UDPersonSmallRow.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 and 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 UDPersonSmallTableInfo instance used in the query behind the reader, you can use the static GetFromReader(SoDataReader, UDPersonSmallTableInfo) 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 UDPersonSmallRows collection, which has nested classes and GetFromIdx methods for each non-unique index. Similarly, there is a GetFromReader(SoDataReader, UDPersonSmallTableInfo) method to retrieve the results of queries that return more than one row.

Unique indexes on table UDPersonSmall are:

Index fields	Nested index class name

Implements

INestedPersist

ISoDataLookup

ISentryIgnorable

ISoItem

Extension Methods

EnumUtil.MapEnums<From, To>(From)

QueryExectionExtensions.ExecuteReader(SqlCommand, Boolean)

QueryExectionExtensions.ExecuteScalar<T>(SqlCommand)

QueryExectionExtensions.ExecuteScalar<T>(SqlCommand, Boolean)

QueryExectionExtensions.ExecuteNonQuery(SqlCommand)

UDPersonSmallRecordDataExtensions.ToRecordData(UDPersonSmallRow)

Converters.MapEnums<From, To>(From)