EntitySelection
An entity selection is an object containing one or more reference(s) to entities belonging to the same Dataclass. Uma seleção de entidades pode conter 0, 1 ou X entidades da dataclass -- onde X pode representar o número total de entidades contidas na dataclass.
Entity selections can be created from existing selections using various functions of the DataClass
class such as .all()
or .query()
, or functions of the EntityClass
class itself, such as .and()
or orderBy()
. You can also create blank entity selections using the dataClass.newSelection()
function or the Create new selection
command.
Resumo
[index] : 4D.Entity allows you to access entities within the entity selection using the standard collection syntax |
.attributeName : Collection .attributeName : 4D.EntitySelection a "projection" of values for the attribute in the entity selection |
.add( entity : 4D.Entity ) : 4D.EntitySelection .add( entitySelection : 4D.EntitySelection ) : 4D.EntitySelection adds the specified entity or entitySelection to the original entity selection and returns the modified entity selection |
.and( entity : 4D.Entity ) : 4D.EntitySelection .and( entitySelection : 4D.EntitySelection ) : 4D.EntitySelection combines the entity selection with an entity or entitySelection parameter using the logical AND operator |
.at( index : Integer ) : 4D.Entity returns the entity at position index, allowing for positive and negative integer |
.average( attributePath : Text ) : Real returns the arithmetic mean (average) of all the non-null values of attributePath in the entity selection |
.contains( entity : 4D.Entity ) : Boolean returns true if entity reference belongs to the entity selection |
.copy( { option : Integer } ) : 4D.EntitySelection returns a copy of the original entity selection |
.count( attributePath : Text ) : Real returns the number of entities in the entity selection with a non-null value in attributePath |
.distinct( attributePath : Text { ; options : Integer } ) : Collection returns a collection containing only distinct (different) values from the attributePath in the entity selection |
.distinctPaths( attribute : Text ) : Collection returns a collection of distinct paths found in the indexed object attribute for the entity selection |
.drop( { mode : Integer } ) : 4D.EntitySelection removes the entities belonging to the entity selection from the table related to its dataclass within the datastore |
.extract( attributePath : Text { ; option : Integer } ) : Collection .extract( attributePath { ; targetPath } { ; ...attributePathN : Text ; targetPathN : Text } ) : Collection returns a collection containing attributePath values extracted from the entity selection |
.first() : 4D.Entity returns a reference to the entity in the first position of the entity selection |
.getDataClass() : 4D.DataClass returns the dataclass of the entity selection |
.getRemoteContextAttributes() : Text returns information about the optimization context used by the entity |
.isAlterable() : Boolean returns True if the entity selection is alterable |
.isOrdered() : Boolean returns True if the entity selection is ordered |
.last() : 4D.Entity returns a reference to the entity in last position of the entity selection |
.length : Integer returns the number of entities in the entity selection |
.max( attributePath : Text ) : any returns the highest (or maximum) value among all the values of attributePath in the entity selection |
.min( attributePath : Text ) : any returns the lowest (or minimum) value among all the values of attributePath in the entity selection |
.minus( entity : 4D.Entity { ; keepOrder : Integer } ) : 4D.EntitySelection .minus( entitySelection : 4D.EntitySelection { ; keepOrder : Integer } ) : 4D.EntitySelection excludes from the entity selection to which it is applied the entity or the entities of entitySelection and returns the resulting entity selection |
.or( entity : 4D.Entity ) : 4D.EntitySelection .or( entitySelection : 4D.EntitySelection ) : 4D.EntitySelection combines the entity selection with the entity or entitySelection parameter using the logical (not exclusive) OR operator |
.orderBy( pathString : Text ) : 4D.EntitySelection .orderBy( pathObjects : Collection ) : 4D.EntitySelection returns a new ordered entity selection containing all entities of the entity selection in the order specified by pathString or pathObjects criteria |
.orderByFormula( formulaString : Text { ; sortOrder : Integer } { ; settings : Object} ) : 4D.EntitySelection .orderByFormula( formulaObj : Object { ; sortOrder : Integer } { ; settings : Object} ) : 4D.EntitySelection returns a new, ordered entity selection |
.query( queryString : Text { ; ...value : any } { ; querySettings : Object } ) : 4D.EntitySelection .query( formula : Object { ; querySettings : Object } ) : 4D.EntitySelection searches for entities that meet the search criteria specified in queryString or formula and (optionally) value(s) among all the entities in the entity selection |
.queryPath : Text contains a detailed description of the query as it was actually performed by 4D |
.queryPlan : Text contains a detailed description of the query just before it is executed (i.e., the planned query) |
.refresh() immediately "invalidates" the entity selection data in the local ORDA cache |
.selected( selectedEntities : 4D.EntitySelection ) : Object returns an object describing the position(s) of selectedEntities in the original entity selection |
.slice( startFrom : Integer { ; end : Integer } ) : 4D.EntitySelection returns a portion of an entity selection into a new entity selection |
.sum( attributePath : Text ) : Real returns the sum for all attributePath values in the entity selection |
.toCollection( { options : Integer { ; begin : Integer { ; howMany : Integer } } ) : Collection .toCollection( filterString : Text {; options : Integer { ; begin : Integer { ; howMany : Integer }}} ) : Collection .toCollection( filterCol : Collection {; options : Integer { ; begin : Integer { ; howMany : Integer }}} ) : Collection creates and returns a collection where each element is an object containing a set of properties and values |
Criar uma seleção de entidades (entity selection)
Create entity selection ( dsTable : Table { ; settings : Object } ) : 4D.EntitySelection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
dsTable | Tabela | -> | Tabela do banco de dados 4D cuja seleção atual se utilizará para construir a seleção de entidades |
settings | Object | -> | Opção de construção: context |
Resultados | 4D. EntitySelection | <- | Seleção de entidades que coincidem com a classe de dados relacionada com a tabela dada |
Descrição
The Create entity selection
command builds and returns a new, alterable entity selection related to the dataclass matching the given dsTable, according to the current selection of this table.
If the current selection is sorted, an ordered entity selection is created (the order of the current selection is kept). Se a seleção atual não for ordenada, se cria uma seleção de entidades não ordenada.
If the dsTable is not exposed in ds
, an error is returned. Esse comando não pode usado com uma datastore remota.
In the optional settings parameter, you can pass an object containing the following property:
Propriedade | Tipo | Descrição |
---|---|---|
context | Text | Label for the optimization context applied to the entity selection. |
Exemplo
var $employees : cs. EmployeeSelection ALL RECORDS([Employee])
$employees:=Create entity selection([Employee])
// A entity selection $employees agora contém um conjunto de referências
// em todas as entidades relacionadas com a classe de dados Employee
Veja também
USE ENTITY SELECTION
USE ENTITY SELECTION (entitySelection)
Parâmetro | Tipo | Descrição | |
---|---|---|---|
entitySelection | EntitySelection | -> | Seleção de entidades |
Descrição
The USE ENTITY SELECTION
command updates the current selection of the table matching the dataclass of the entitySelection parameter, according to the content of the entity selection.
This command cannot be used with a Remote datastore.
Esse comando foi projetado para fazer com que as seleções de corrente 4D se beneficiem do poder das consultas ORDA. For performance reasons, in 4D single-user and 4D Server, the command directly connects entitySelection to the current selection. Portanto, uma vez que a entitySelection tenha sido usada, ela não deve ser reutilizada ou alterada posteriormente.
After a call to USE ENTITY SELECTION
, the first record of the updated current selection (if not empty) becomes the current record, but it is not loaded in memory. If you need to use the values of the fields in the current record, use the LOAD RECORD
command after the USE ENTITY SELECTION
command.
Exemplo
var $entitySel : cs.EmployeeSelection
$entitySel:=ds.Employee.query("lastName = :1"; "M@") //$entitySel está relacionado à classe de dados Employee
REDUCE SELECTION([Employee];0)
USE ENTITY SELECTION($entitySel) //A seleção atual da tabela Employee é atualizada
[index]
História
Release | Mudanças |
---|---|
17 | Adicionado |
[index] : 4D.Entity
Descrição
The EntitySelection[index]
notation allows you to access entities within the entity selection using the standard collection syntax: pass the position of the entity you want to get in the index parameter.
Lembre que a entidade correspondente é recarregada a partir da datastore.
index pode ser qualquer número entre 0 e .length
-1.
- Se index está fora do intervalo, se devolve um erro.
- If index corresponds to a dropped entity, a Null value is returned.
EntitySelection[index]
is a non assignable expression, which means that it cannot be used as en editable entity reference with methods like .lock()
or .save()
. Para trabalhar com a entidade correspondente, é necessário atribuir a expressão devolvida a uma expressão atribuível, como uma variável. Exemplos:
$sel:=ds. Employee.all() //criação da entity selection
//declarações não válidas:
$result:=$sel[0].lock() //NÃO funcionará
$sel[0].lastName:="Smith" //NÃO funcionará
$result:=$sel[0].save() //NÃO funcionará
//valid code:
$entity:=$sel[0] //OK
$entity.lastName:="Smith" //OK
$entity.save() //OK
Exemplo
var $employees : cs. EmployeeSelection
var $employee : cs. EmployeeEntity
$employees:=ds. Employee.query("lastName = :1";"H@")
$employee:=$employees[2] // A terceira entidade da seleção de entidades $employees se recarrega do banco de dados
.attributeName
História
Release | Mudanças |
---|---|
17 | Adicionado |
.attributeName : Collection
.attributeName : 4D.EntitySelection
Descrição
Any dataclass attribute can be used as a property of an entity selection to return a "projection" of values for the attribute in the entity selection. Projected values can be a collection or a new entity selection, depending on the kind (storage
or relation
) of the attribute.
- If attributeName kind is
storage
:.attributeName
returns a collection of values of the same type as attributeName. - If attributeName kind is
relatedEntity
:.attributeName
returns a new entity selection of related values of the same type as attributeName. Se eliminam os duplicados (se devolve uma seleção de entidades desordenada). - If attributeName kind is
relatedEntities
:.attributeName
returns a new entity selection of related values of the same type as attributeName. Se eliminam os duplicados (se devolve uma seleção de entidades desordenada).
Quando se utiliza um atributo de relação como propriedade de uma seleção de entidades, o resultado é sempre outra seleção de entidades, mesmo que só se devolva uma entidade. If the original entity selection and the entitySelection parameter are empty, an empty entity selection is returned.
Se o atributo não existir na seleção de entidades, se devolve um erro.
Exemplo 1
Projeção de valores de armazenamento:
var $firstNames : Collection
$entitySelection:=ds. Employee.all()
$firstNames:=$entitySelection.firstName // firstName é um string
A coleção resultante é uma coleção de strings, por exemplo:
[
"Joanna",
"Alexandra",
"Rick"
]
Exemplo 2
Projeção da entidade relacionada:
var $es; $entitySelection : cs. EmployeeSelection
$entitySelection:=ds. Employee.all()
$es:=$entitySelection.employer // employer é relacionada aum Company dataClass
O objeto resultane é uma seleção de entidade da Empresa com duplicações removidas (se houver).
Exemplo 3
Projeção de entidades relacionadas:
var $es : cs. EmployeeSelection
$es:=ds. Employee.all().directReports // directReports é relacionada a dataclasse Funcionário
O objeto resultante é uma seleção de entidade da dataclasse Funcionario sem duplicatas (se houver).
.add()
História
Release | Mudanças |
---|---|
18 R6 | Suporte do parâmetro entitySelection |
18 R5 | Compatível apenas com seleções de entidade alteráveis |
17 | Adicionado |
.add( entity : 4D.Entity ) : 4D.EntitySelection
.add( entitySelection : 4D.EntitySelection ) : 4D.EntitySelection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
entity | 4D. Entity | -> | Entidade que deve ser adicinonada à entity selection |
entitySelection | 4D. EntitySelection | -> | Seleção entidade paara ser adicionado a sellleção entidade originaal |
Resultados | 4D. EntitySelection | -> | Seleção de entidades, incluindo a entity ou entitySelection adicionada |
Descrição
The .add()
function adds the specified entity or entitySelection to the original entity selection and returns the modified entity selection.
Esta função não modifica a entity selection original.
The entity selection must be alterable, i.e. it has been created for example by .newSelection()
or Create entity selection
, otherwise .add()
will return an error. As entity selections partilháveis não aceitam a adição de entidades. For more information, please refer to the Shareable or alterable entity selections section.
Adicionar uma entidade
- If the entity selection is ordered, entity is added at the end of the selection. Se uma referência a mesma entidade já pertencer a seleção de entidades, se duplica e se adiciona uma nova referência.
- Se a seleção da entidade não tiver ordem, entity é adicionada em qualquer lugar da seleção, sem uma ordem específica.
Adicionar uma seleção de entidades
- Se a selecção de entidades estiver ordenada, a sua ordem é mantida e entitySelection é adicionado no final da selecção. If references to the same entities of entitySelection already belong to the entity selection, they are duplicated and new references are added.
- Se a seleção de entidade nãofor ordenada, ela fica ordenada.
For more information, please refer to the Ordered or unordered entity selection section.
A entity selection modificada é devolvida pela função, de modo que as chamadas à função podem ser encadeados.
An error occurs if entity and the entity selection are not related to the same Dataclass. Se entity for Null, não se produz nenhum erro.
Exemplo 1
var $employees : cs. EmployeeSelection
var $employee : cs. EmployeeEntity
$employees:=ds. Employee.query("lastName = :1";"S@")
$employee:=ds. Employee.new()
$employee.lastName:="Smith"
$employee.save()
$employees.add($employee) //A entidade $employee se adiciona a entity selection $employees
Exemplo 2
As chamadas à função podem ser encadeadas:
var $sel : cs. ProductSelection
var $p1;$p2;$p3 : cs. ProductEntity
$p1:=ds. Product.get(10)
$p2:=ds. Product.get(11)
$p3:=ds. Product.get(12)
$sel:=ds. Product.query("ID > 50")
$sel:=$sel.add($p1).add($p2).add($p3)
Exemplo 3
Em uma interface de usuário, temos duas listas. O usuário seleciona itens da lista 1 e as adiciona na lista 2.
$sellist2:=$sellist2.add($sellist1)
.and()
História
Release | Mudanças |
---|---|
17 | Adicionado |
.and( entity : 4D.Entity ) : 4D.EntitySelection
.and( entitySelection : 4D.EntitySelection ) : 4D.EntitySelection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
entity | 4D. Entity | -> | Entidade a intersectar |
entitySelection | 4D. EntitySelection | -> | Entity selection a intersectar |
Resultados | 4D. EntitySelection | <- | Entity selection resultante da intersecção com o operador lógico AND |
Descrição
The .and()
function combines the entity selection with an entity or entitySelection parameter using the logical AND operator; it returns a new, unordered entity selection that contains only the entities that are referenced in both the entity selection and the parameter.
- If you pass entity as parameter, you combine this entity with the entity selection. Se a entidade pertencer à entity selection, se devolve uma nova entity selection que só contém a entidade. Senão, uma seleção de entidades vazia é retornada.
- If you pass entitySelection as parameter, you combine both entity selections. Uma nova seleção de entidade que contenha só as entidades que são referenciadas em ambas as seleções sejam retornadas. Senão, uma nova seleção de entidade contém a seleção de entidade original e a entidade é retornada.
You can compare ordered and/or unordered entity selections. A seleção resultante é sempre desordenada.
If the original entity selection or the entitySelection parameter is empty, or if the entity is Null, an empty entity selection is returned.
Se a entity selection inicial e o parâmetro não forem relacionados com a mesma dataclass, se produz um erro.
Exemplo 1
var $employees; $result : cs.EmployeeSelection
var $employee : cs.EmployeeEntity
$employees:=ds.Employee.query("lastName = :1";"H@")
//The $employees entity selection contains the entity
//with primary key 710 and other entities
//for ex. "Colin Hetrick" / "Grady Harness" / "Sherlock Holmes" (primary key 710)
$employee:=ds.Employee.get(710) // Returns "Sherlock Holmes"
$result:=$employees.and($employee) //$result is an entity selection containing
//only the entity with primary key 710 ("Sherlock Holmes")
Exemplo 2
Se quisermos ter uma seleção de empregados chamados "Jones" que morem em Nova York:
var $sel1; $sel2; $sel3 : cs.EmployeeSelection
$sel1:=ds.Employee.query("name =:1";"Jones")
$sel2:=ds.Employee.query("city=:1";"New York")
$sel3:=$sel1.and($sel2)
.at()
História
Release | Mudanças |
---|---|
20 | Adicionado |
.at( index : Integer ) : 4D.Entity
Parâmetro | Tipo | Descrição | |
---|---|---|---|
index | Integer | -> | Índice da entidade a devolver |
Resultados | 4D. Entity | <- | A entidade nesse índice |
Descrição
The .at()
function returns the entity at position index, allowing for positive and negative integer.
If index is negative (from -1 to -n with n : length of the entity selection), the returned entity will be based on the reverse order of the entity selection.
A função devolve Null se o index estiver para além dos limites de selecção de entidades.
Exemplo
var $employees : cs.EmployeeSelection
var $emp1; $emp2 : cs.EmployeeEntity
$employees:=ds.Employee.query("lastName = :1";"H@")
$emp1:=$employees.at(2) //3rd entity of the $employees entity selection
$emp2:=$employees.at(-3) //starting from the end, 3rd entity
//of the $employees entity selection
.average()
História
Release | Mudanças |
---|---|
18 R6 | Retorna indefinido se uma seleção de entidade for vazia |
17 | Adicionado |
.average( attributePath : Text ) : Real
Parâmetro | Tipo | Descrição | |
---|---|---|---|
attributePath | Text | -> | Rota do atributo que se utilizará para o cálculo |
Resultados | Real | <- | Media aritmética (média) dos valores das entidades para o atributo (Não se define para uma entity selection vazia) |
Descrição
The .average()
function returns the arithmetic mean (average) of all the non-null values of attributePath in the entity selection.
Pass in the attributePath parameter the attribute path to evaluate.
Só são levados em consideração os valores numéricos para o cálculo. Note however that, if the attributePath of the entity selection contains mixed value types, .average()
takes all scalar elements into account to calculate the average value.
Os valores de tipo Date são convertidos em valores numéricos (segundos) e são usados para calcular a média.
.average()
returns undefined if the entity selection is empty or attributePath does not contain numerical values.
Um erro é retornado se:
- attributePath is a related attribute,
- attributePath não se encontra na classe de dados da entity selection.
Exemplo
Se quisermos obter uma lista de funcionários cujo salário for superior ao salário médio:
var $averageSalary : Real
var $moreThanAv : cs.EmployeeSelection
$averageSalary:=ds.Employee.all().average("salary")
$moreThanAv:=ds.Employee.query("salary > :1";$averageSalary)
.contains()
História
Release | Mudanças |
---|---|
17 | Adicionado |
.contains( entity : 4D.Entity ) : Boolean
Parâmetro | Tipo | Descrição | |
---|---|---|---|
entity | 4D. Entity | -> | Entidade a ser avaliada |
Resultados | Parâmetros | <- | Truse se a entidade pertencer à entity selection, senão False |
Descrição
The .contains()
function returns true if entity reference belongs to the entity selection, and false otherwise.
In entity, specify the entity to search for in the entity selection. Se a entidade for Null, a função devolverá false.
Se entity e a entity selection não pertencerem à mesma dataclass, se produz um erro.
Exemplo
var $employees : cs.EmployeeSelection
var $employee : cs.EmployeeEntity
$employees:=ds.Employee.query("lastName=:1";"H@")
$employee:=ds.Employee.get(610)
If($employees.contains($employee))
ALERT("The entity with primary key 610 has a last name beginning with H")
Else
ALERT("The entity with primary key 610 does not have a last name beginning with H")
End if
.count()
História
Release | Mudanças |
---|---|
17 | Adicionado |
.count( attributePath : Text ) : Real
Parâmetro | Tipo | Descrição | |
---|---|---|---|
attributePath | Text | -> | Rota do atributo que se utilizará para o cálculo |
Resultados | Real | <- | Número de valores de attributePath que não são null na entity selection |
Descrição
The .count()
function returns the number of entities in the entity selection with a non-null value in attributePath.
Só são levados em consideração os valores escalares. Os valores de tipo objeto ou coleção são considerados valores nulos.
Um erro é retornado se:
- attributePath is a related attribute,
- attributePath não se encontra na classe de dados da entity selection.
Exemplo
Se quisermos encontrar o número total de empregados para uma empresa sem contar aqueles cujos titulos de mprego não foram especificados:
var $sel : cs.EmployeeSelection
var $count : Real
$sel:=ds.Employee.query("employer = :1";"Acme, Inc")
$count:=$sel.count("jobtitle")
.copy()
História
Release | Mudanças |
---|---|
18 R5 | Adicionado |
.copy( { option : Integer } ) : 4D.EntitySelection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
option | Integer | -> | ck shared : return a shareable entity selection |
Resultados | 4D. EntitySelection | <- | Cópia da entity selection |
Descrição
The .copy()
function returns a copy of the original entity selection.
Esta função não modifica a seleção de entidades original.
By default, if the option parameter is omitted, the function returns a new, alterable entity selection (even if the function is applied to a shareable entity selection). Pass the ck shared
constant in the option parameter if you want to create a shareable entity selection.
For information on the shareable property of entity selections, please refer to the Shareable or alterable entity selections section.
Exemplo
Se criar uma nova seleção de entidade vazia de produtos quando o formulário for carregado:
Case of
:(Form event code=On Load)
Form.products:=ds.Products.newSelection()
End case
Então esta seleção de entidades é atualizada com produtos e se quiser compartilhar os produtos entre vários processos. Se copiar a seleçãod a entidade Form.products como compartilhável:
...
// The Form.products entity selection is updated
Form.products.add(Form.selectedProduct)
Use(Storage)
If(Storage.products=Null)
Storage.products:=New shared object()
End if
Use(Storage.products)
Storage.products:=Form.products.copy(ck shared)
End use
End use
.distinct()
História
Release | Mudanças |
---|---|
20 | Suporte de dk count values |
17 | Adicionado |
.distinct( attributePath : Text { ; options : Integer } ) : Collection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
attributePath | Text | -> | Rota do atributo cujos valores quer obter |
options | Integer | -> | dk diacritical , dk count values |
Resultados | Collection | <- | Coleção apenas com valores distintos |
Descrição
The .distinct()
function returns a collection containing only distinct (different) values from the attributePath in the entity selection.
A coleção retornada é ordenada automaticamente. Os valores null não são devolvidos.
In the attributePath parameter, pass the entity attribute whose distinct values you want to get. Só valores escalares (texto, número, booleano, ou data) podemser manejados. If the attributePath leads to an object property that contains values of different types, they are first grouped by type and sorted afterwards. Se attributePath levar a uma propriedade de objeto que conter valores de diferentes tipos, primeiro se agrupam por tipo e se ordenam depois.
- booleans
- strings
- números
- datas
You can use the []
notation to designate a collection when attributePath is a path within an object (see examples).
In the options parameter, you can pass one or a combination of the following constants:
Parâmetros | Valor | Comentário |
---|---|---|
dk diacritical | 8 | A avaliação é sensível a maiúsculas e minúsculas e diferencia os caracteres acentuados. Como padrão, uma avaliação não-diacrítica é realizada. |
dk count values | 32 | Devolve a contagem de entidades para cada valor distinto. When this option is passed, .distinct() returns a collection of objects containing a pair of {"value":*value*; "count":*count*} properties. |
The dk count values
option is only available with storage attributes of type boolean, string, number, and date.
Um erro é retornado se:
- attributePath is a related attribute,
- attributePath não se encontra na classe de dados da entity selection.
Exemplos
Se quiser obter uma coleção que contenha um só elemento por nome de país:
var $countries : Collection
$countries:=ds. Employee.all().distinct("address.country")
nicknames
is a collection and extra
is an object attribute:
$values:=ds. Employee.all().distinct("extra.nicknames[].first")
Pretende obter o número de nomes de funções diferentes na empresa:
var $jobs : Collection
$jobs:=ds. Employee.all().distinct("jobName";dk count values)
//$jobs[0]={"value":"Developer";"count":17}
//$jobs[1]={"value":"Office manager";"count":5}
//$jobs[2]={"value":"Accountant";"count":2}
//...
.distinctPaths()
História
Release | Mudanças |
---|---|
20 | Adicionado |
.distinctPaths( attribute : Text ) : Collection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
atributo | Text | -> | Nome do atributo do objecto cujos caminhos pretende obter |
Resultados | Collection | <- | Nova colecção com caminhos distintos |
Descrição
The .distinctPaths()
function returns a collection of distinct paths found in the indexed object attribute for the entity selection.
If attribute is not an indexed object attribute, an error is generated.
After the call, the size of the returned collection is equal to the number of distinct paths found in attribute for the entity selection. Os caminhos são devolvidos como cadeias de caracteres, incluindo atributos e colecções aninhados, por exemplo "info.address.number" ou "children[].birthdate". Entities with a null value in the attribute are not taken into account.
Exemplo
Você deseja obter todos os caminhos armazenados em um atributo objeto fullData:
var $paths : Collection
$paths:=ds. Employee.all().distinctPaths("fullData")
//$paths[0]="age"
//$paths[1]="Children"
//$paths[2]="Children[].age"
//$paths[3]="Children[].name"
//$paths[4]="Children.length"
///...
length is automatically added as path for nested collection properties.
.drop()
História
Release | Mudanças |
---|---|
17 | Adicionado |
.drop( { mode : Integer } ) : 4D.EntitySelection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
mode | Integer | -> | dk stop dropping on first error : para a execução do método na primeira entidade não eliminável |
Resultados | 4D. EntitySelection | <- | Seleção de entidade vazia se bem-sucedida; caso contrário, seleção de entidade contendo entidades não descartáveis |
Descrição
The .drop()
function removes the entities belonging to the entity selection from the table related to its dataclass within the datastore. A entity selection permanece na memória.
A eliminação de entidades é permanente e não pode ser desfeita. É recomendado chamar esta ação em uma transação para ter uma opção de recuperação.
Se encontrar uma entidade bloqueada durante a execução de .drop()
, não é eliminado. Como padrão o método processa todas as entidades da seleção de entidades e retorna as entidades não elimináveis na entity selection. If you want the method to stop execution at the first encountered non-droppable entity, pass the dk stop dropping on first error
constant in the mode parameter.
Exemplo
Example without the dk stop dropping on first error
option:
var $employees; $notDropped : cs.EmployeeSelection
$employees:=ds.Employee.query("firstName=:1";"S@")
$notDropped:=$employees.drop() // $notDropped is an entity selection containing all the not dropped entities
If($notDropped.length=0) //The delete action is successful, all the entities have been deleted
ALERT("You have dropped "+String($employees.length)+" employees") //The dropped entity selection remains in memory
Else
ALERT("Problem during drop, try later")
End if
Example with the dk stop dropping on first error
option:
var $employees; $notDropped : cs.EmployeeSelection
$employees:=ds.Employee.query("firstName=:1";"S@")
$notDropped:=$employees.drop(dk stop dropping on first error) //$notDropped is an entity selection containing the first not dropped entity
If($notDropped.length=0) //The delete action is successful, all the entities have been deleted
ALERT("You have dropped "+String($employees.length)+" employees") //The dropped entity selection remains in memory
Else
ALERT("Problem during drop, try later")
End if
.extract()
História
Release | Mudanças |
---|---|
18 R3 | Adicionado |
.extract( attributePath : Text { ; option : Integer } ) : Collection
.extract( attributePath { ; targetPath } { ; ...attributePathN : Text ; targetPathN : Text } ) : Collection
Parâmetro | Tipo | Descrição | |
---|---|---|---|
attributePath | Text | -> | Rota de atributo cujos valores serão extraídos para nova coleção |
targetpath | Text | -> | Rota ou nome do atributo objetivo |
option | Integer | -> | ck keep null : include null attributes in the returned collection (ignored by default) |
Resultados | Collection | <- | Coleção contendo valores extraídos |
Descrição
The .extract()
function returns a collection containing attributePath values extracted from the entity selection.
attributePath pode se referir a:
- um atributo escalar de dataclass,
- entidade relacionada,
- entidades relacionadas.
Se attributePath não for válido, se devolve uma coleção vazia.
Esta função aceita duas sintaxes.
.extract( attributePath : Text { ; option : Integer } ) : Collection
With this syntax, .extract()
populates the returned collection with the attributePath values of the entity selection.
By default, entities for which attributePath is null or undefined are ignored in the resulting collection. You can pass the ck keep null
constant in the option parameter to include these values as null elements in the returned collection.
- Dataclass attributes with .kind = "relatedEntity" are extracted as a collection of entities (duplications are kept).
- Dataclass attributes with .kind = "relatedEntities" are extracted as a collection of entity selections.
.extract ( attributePath ; targetPath { ; ...attributePathN ; ... targetPathN}) : Collection
With this syntax, .extract()
populates the returned collection with the attributePath properties. Each element of the returned collection is an object with targetPath properties filled with the corresponding attributePath properties. Null values are kept (option parameter is ignored with this syntax).
If several attributePath are given, a targetPath must be given for each. Somente pares válidos [attributePath, targetPath] são extraídos.
- Os atributos dataclass com .kind = "relatedEntity" são extraídos como uma entidade.
- Dataclass attributes with .kind = "relatedEntities" are extracted as an entity selection.
As entidades de uma colecção de entidades acedidas por [ ] não são recarregadas da base de dados.
Exemplo
Dada a seguinte tabela e relação:
var $firstnames; $addresses; $mailing; $teachers : Collection
//
//
//$firstnames is a collection of Strings
$firstnames:=ds.Teachers.all().extract("firstname")
//
//$addresses is a collection of entities related to dataclass Address
//Null values for address are extracted
$addresses:=ds.Teachers.all().extract("address";ck keep null)
//
//
//$mailing is a collection of objects with properties "who" and "to"
//"who" property content is String type
//"to" property content is entity type (Address dataclass)
$mailing:=ds.Teachers.all().extract("lastname";"who";"address";"to")
//
//
//$mailing is a collection of objects with properties "who" and "city"
//"who" property content is String type
//"city" property content is String type
$mailing:=ds.Teachers.all().extract("lastname";"who";"address.city";"city")
//
//$teachers is a collection of objects with properties "where" and "who"
//"where" property content is String
//"who" property content is an entity selection (Teachers dataclass)
$teachers:=ds.Address.all().extract("city";"where";"teachers";"who")
//
//$teachers is a collection of entity selections
$teachers:=ds.Address.all().extract("teachers")
.first()
História
Release | Mudanças |
---|---|
17 | Adicionado |
.first() : 4D.Entity
Parâmetro | Tipo | Descrição | |
---|---|---|---|
Resultados | 4D. Entity | <- | Referência para a primeira entidade da seleção da entidade (Null se a seleção estiver vazia) |
Descrição
The .first()
function returns a reference to the entity in the first position of the entity selection.
O resultado desta função é similar a:
$entity:=$entitySel[0]
Há, entretanto, uma diferença entre ambas as afirmações quando a seleção estiver vazia:
var $entitySel : cs.EmpSelection
var $entity : cs.EmpEntity
$entitySel:=ds.Emp.query("lastName = :1";"Nonexistentname") //no matching entity
//entity selection is then empty
$entity:=$entitySel.first() //returns Null
$entity:=$entitySel[0] //generates an error
Exemplo
var $entitySelection : cs.EmpSelection
var $entity : cs.EmpEntity
$entitySelection:=ds.Emp.query("salary > :1";100000)
If($entitySelection.length#0)
$entity:=$entitySelection.first()
End if
.getDataClass()
História
Release | Mudanças |
---|---|
17 R5 | Adicionado |
.getDataClass() : 4D.DataClass
Parâmetro | Tipo | Descrição | |
---|---|---|---|
Resultados | 4D. DataClass | <- | Objeto dataclass ao qual a seleção de entidade pertence |
Descrição
The .getDataClass()
function returns the dataclass of the entity selection.
Esta função é principalmente útil no contexto do código genérico.
Exemplo
O seguinte código genérico duplica todas as entidades da entity selection:
//duplicate_entities method
//duplicate_entities($entity_selection)
#DECLARE ( $entitySelection : 4D.EntitySelection )
var $dataClass : 4D.DataClass
var $entity; $duplicate : 4D.Entity
var $status : Object
$dataClass:=$entitySelection.getDataClass()
For each($entity;$entitySelection)
$duplicate:=$dataClass.new()
$duplicate.fromObject($entity.toObject())
$duplicate[$dataClass.getInfo().primaryKey]:=Null //reset the primary key
$status:=$duplicate.save()
End for each
.getRemoteContextAttributes()
História
Release | Mudanças |
---|---|
19R5 | Adicionado |
.getRemoteContextAttributes() : Text
Parâmetro | Tipo | Descrição | |
---|---|---|---|
result | Text | <- | Atributos de contexto conectados à seleção de entidade, separados por uma vírgula |
Advanced mode: This function is intended for developers who need to customize ORDA default features for specific configurations. Na maioria dos casos, não necessitará de o utilizar.
Descrição
The .getRemoteContextAttributes()
function returns information about the optimization context used by the entity selection.
If there is no optimization context for the entity selection, the function returns an empty Text.
Exemplo
var $ds : 4D. DataStoreImplementation
var $persons : cs. PersonsSelection
var $p : cs. PersonsEntity
var $info : Text
var $text : Text
$ds:=Open datastore(New object("hostname"; "www.myserver.com"); "myDS")
$persons:=$ds. Persons.all()
$text:="" For each ($p; $persons)
$text:=$p.firstname+" lives in "+$p.address.city+" / " End for each
$info:=$persons.getRemoteContextAttributes()
//$info = "firstname,address,address.city"
Veja também
Entity.getRemoteContextAttributes()
.clearAllRemoteContexts()
.getRemoteContextInfo()
.getAllRemoteContexts()
.setRemoteContextInfo()
.isAlterable()
História
Release | Mudanças |
---|---|
18 R5 | Adicionado |
.isAlterable() : Boolean
Parâmetro | Tipo | Descrição | |
---|---|---|---|
Resultados | Parâmetros | <- | True se a seleção de entidades for alterável, senão False |
Descrição
The .isAlterable()
function returns True if the entity selection is alterable, and False if the entity selection is not alterable.
For more information, please refer to Shareable or alterable entity selections.
Exemplo
You are about to display Form.products
in a list box to allow the user to add new products. Se quiser ter certeza que é alterável para que o usuário possa adicionar novos produtos sem erro:
If (Not(Form.products.isAlterable()))
Form.products:=Form.products.copy()
End if
...
Form.products.add(Form.product)